[mlir][bufferize] Rename BufferAssignment* to Bufferize*

[silvas]

Summary

Part of the refactor discussed in:
https://llvm.discourse.group/t/what-is-the-strategy-for-tensor-memref-conversion-bufferization/1938/17

[herhut]

It would be great to have more consistency wrt. naming of patterns and passes but this is a step in the right direction.

Left comments for further improvements but those need not be in this change.

mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h

801

Why are these in a header file?

807

Should we aim for a somewhat standardized name for the patterns themselves? Like BufferizeLinalgOpConverter or LinalgOpBufferizer?

mlir/include/mlir/Dialect/Shape/Transforms/Passes.h

43–45

Do we keep the name TypeConversionPatterns? Or should this also become BufferizeOpConversionPatterns? I think the latter is also already in use.

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

124–125

This comment is off.

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

23

Could this also be renamed?

77

Here, too. Also scrap the TODO?

The BufferizeTypeConverter allows to configure how types should be rewritten.

[dfki-mako]

mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h

807

@herhut sounds good to me. Maybe we should aim for LinalgOpBufferizer.

mlir/include/mlir/Dialect/Shape/Transforms/Passes.h

43–45

I guess it makes sense to unify these names in a way that they express their association to the internal Bufferize functionality.

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

124–125

This comment is out-of-date and should be adapted.

mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h

 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/Identifier.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/Bufferize.h"
 #include "llvm/ADT/SmallBitVector.h"
 
 namespace mlir {
 
-class BufferAssignmentTypeConverter;
+class BufferizeTypeConverter;
 
 namespace linalg {
 
 struct LinalgFusionOptions;
 struct LinalgTilingOptions;
 
 //===----------------------------------------------------------------------===//
 // Transformations exposed as function calls.

 
 /// Populates patterns for vectorization of all ConvN-D ops.
 void populateConvVectorizationPatterns(
     MLIRContext *context, SmallVectorImpl<OwningRewritePatternList> &patterns,
     ArrayRef<int64_t> tileSizes);
 
 /// Populates the given list with patterns to bufferize linalg ops.
 void populateLinalgBufferizePatterns(MLIRContext *context,
-                                     BufferAssignmentTypeConverter &converter,
+                                     BufferizeTypeConverter &converter,
                                      OwningRewritePatternList &patterns);
 
 /// Performs standalone tiling of a single LinalgOp by `tileSizes`.
 /// and permute the loop nest according to `interchangeVector`
 /// The permutation is expressed as a list of integers that specify
 /// the new ordering of the loop nest. The length of `interchangeVector`
 /// must be equal to the length of `tileSizes`.
 /// An empty vector is interpreted as the identity permutation and the
LogicalResult matchAndRewrite(IndexedGenericOp op,
                                 PatternRewriter &rewriter) const override;
 };
 
 /// Populate the given list with patterns that convert from Linalg to Standard.
 void populateLinalgToStandardConversionPatterns(
     OwningRewritePatternList &patterns, MLIRContext *ctx);
 
 //===----------------------------------------------------------------------===//
 // Buffer allocation patterns.
 //===----------------------------------------------------------------------===//
 
-/// Generic BufferAssignmentConversionPattern that matches any Operation* and
+/// Generic BufferizeConversionPattern that matches any Operation* and
 /// dispatches internally. This avoids template instantiating one pattern for
 /// each LinalgOp op.
-class LinalgOpConverter : public BufferAssignmentConversionPattern {
+class LinalgOpConverter : public BufferizeConversionPattern {
 public:
-  LinalgOpConverter(MLIRContext *context,
-                    BufferAssignmentTypeConverter &converter)
-      : BufferAssignmentConversionPattern(context, converter) {}
+  LinalgOpConverter(MLIRContext *context, BufferizeTypeConverter &converter)
+      : BufferizeConversionPattern(context, converter) {}
 
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final;
 };
 
 /// TensorConstantOp conversion inserts a linearized 1-D vector constant that is
 /// stored in memory. A linalg.reshape is introduced to convert to the desired
 /// n-D buffer form.
 class TensorConstantOpConverter
-    : public BufferAssignmentOpConversionPattern<ConstantOp> {
+    : public BufferizeOpConversionPattern<ConstantOp> {
 public:
-  using BufferAssignmentOpConversionPattern<
-      ConstantOp>::BufferAssignmentOpConversionPattern;
+  using BufferizeOpConversionPattern<ConstantOp>::BufferizeOpConversionPattern;
 
   LogicalResult
   matchAndRewrite(ConstantOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final;
 };
 
 /// TensorCastOp converts 1-1 to MemRefCastOp.
 class TensorCastOpConverter
-    : public BufferAssignmentOpConversionPattern<TensorCastOp> {
+    : public BufferizeOpConversionPattern<TensorCastOp> {
 public:
-  using BufferAssignmentOpConversionPattern<
-      TensorCastOp>::BufferAssignmentOpConversionPattern;
+  using BufferizeOpConversionPattern<
+      TensorCastOp>::BufferizeOpConversionPattern;
 
   LogicalResult
   matchAndRewrite(TensorCastOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final;
 };
 
 //===----------------------------------------------------------------------===//
 // Support for staged pattern application.

mlir/include/mlir/Dialect/Shape/Transforms/Passes.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SHAPE_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_SHAPE_TRANSFORMS_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
-class BufferAssignmentTypeConverter;
+class BufferizeTypeConverter;
 } // namespace mlir
 
 namespace mlir {
 /// Creates an instance of the ShapeToShapeLowering pass that legalizes Shape
 /// dialect to be convertible to Standard. For example, `shape.num_elements` get
 /// transformed to `shape.reduce`, which can be lowered to SCF and Standard.
 std::unique_ptr<Pass> createShapeToShapeLowering();
 
 /// Collects a set of patterns to rewrite ops within the Shape dialect.
 void populateShapeRewritePatterns(MLIRContext *context,
                                   OwningRewritePatternList &patterns);
 
 // Collects a set of patterns to replace all constraints with passing witnesses.
 // This is intended to then allow all ShapeConstraint related ops and data to
 // have no effects and allow them to be freely removed such as through
 // canonicalization and dead code elimination.
 //
 // After this pass, no cstr_ operations exist.
 void populateRemoveShapeConstraintsPatterns(OwningRewritePatternList &patterns,
                                             MLIRContext *ctx);
 std::unique_ptr<FunctionPass> createRemoveShapeConstraintsPass();
 
-void populateShapeTypeConversionPatterns(
-    MLIRContext *ctx, BufferAssignmentTypeConverter &converter,
+void populateShapeTypeConversionPatterns(MLIRContext *ctx,
+                                         BufferizeTypeConverter &converter,
                                          OwningRewritePatternList &patterns);
 // Bufferizes shape dialect ops.
 //
 // Note that most shape dialect ops must be converted to std before
 // bufferization happens, as they are intended to be bufferized at the std
 // level.
 std::unique_ptr<FunctionPass> createShapeBufferizePass();
 
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Transforms/Bufferize.h

 #include "mlir/IR/Operation.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 namespace mlir {
 
 /// A helper type converter class for using inside Buffer Assignment operation
 /// conversion patterns. The default constructor keeps all the types intact
 /// except for the ranked-tensor types which is converted to memref types.
-class BufferAssignmentTypeConverter : public TypeConverter {
+class BufferizeTypeConverter : public TypeConverter {
 public:
   /// This enum is for showing how buffer placement operation converters should
   /// conduct with certain result type after type conversion. This value can be
   /// set/get for each specific type using setResultConversionKind or
   /// getResultConversionKind.
   enum ResultConversionKind { AppendToArgumentsList, KeepAsFunctionResult };
 
-  BufferAssignmentTypeConverter();
+  BufferizeTypeConverter();
 
   /// This method tries to decompose a value of a certain type using provided
   /// decompose callback functions. If it is unable to do so, the original value
   /// is returned.
   void tryDecomposeValue(OpBuilder &, Location, Type, Value,
                          SmallVectorImpl<Value> &);
 
   /// This method tries to decompose a type using provided decompose callback
wrapDecomposeTypeConversionCallback(FnT &&callback) {
     };
   }
 
   SmallVector<ResultConversionKindFn, 2> resultTypeConversions;
   SmallVector<DecomposeValueConversionCallFn, 2> decomposeValueConversions;
   SmallVector<DecomposeTypeConversionCallFn, 2> decomposeTypeConversions;
 };
 
-/// Helper conversion pattern that encapsulates a BufferAssignmentTypeConverter
+/// Helper conversion pattern that encapsulates a BufferizeTypeConverter
 /// instance.
 template <typename SourceOp>
-class BufferAssignmentOpConversionPattern
-    : public OpConversionPattern<SourceOp> {
+class BufferizeOpConversionPattern : public OpConversionPattern<SourceOp> {
 public:
-  explicit BufferAssignmentOpConversionPattern(
-      MLIRContext *context, BufferAssignmentTypeConverter &converter,
+  explicit BufferizeOpConversionPattern(MLIRContext *context,
+                                        BufferizeTypeConverter &converter,
                                         PatternBenefit benefit = 1)
       : OpConversionPattern<SourceOp>(context, benefit), converter(converter) {}
 
 protected:
-  BufferAssignmentTypeConverter &converter;
+  BufferizeTypeConverter &converter;
 };
 
-/// Helper conversion pattern that encapsulates a BufferAssignmentTypeConverter
+/// Helper conversion pattern that encapsulates a BufferizeTypeConverter
 /// instance and that operates on Operation* to be compatible with OpInterfaces.
 /// This allows avoiding to instantiate N patterns for ops that can be subsumed
 /// by a single op interface (e.g. Linalg named ops).
-class BufferAssignmentConversionPattern : public ConversionPattern {
+class BufferizeConversionPattern : public ConversionPattern {
 public:
-  explicit BufferAssignmentConversionPattern(
-      MLIRContext *context, BufferAssignmentTypeConverter &converter,
+  explicit BufferizeConversionPattern(MLIRContext *context,
+                                      BufferizeTypeConverter &converter,
                                       PatternBenefit benefit = 1)
       : ConversionPattern(benefit, converter, MatchAnyOpTypeTag()),
         converter(converter) {}
 
 protected:
-  BufferAssignmentTypeConverter &converter;
+  BufferizeTypeConverter &converter;
 };
 
-/// Converts the signature of the function using BufferAssignmentTypeConverter.
+/// Converts the signature of the function using BufferizeTypeConverter.
 /// Each result type of the function is kept as a function result or appended to
 /// the function arguments list based on ResultConversionKind for the converted
 /// result type.
-class BufferAssignmentFuncOpConverter
-    : public BufferAssignmentOpConversionPattern<FuncOp> {
+class BufferizeFuncOpConverter : public BufferizeOpConversionPattern<FuncOp> {
 public:
-  using BufferAssignmentOpConversionPattern<
-      FuncOp>::BufferAssignmentOpConversionPattern;
+  using BufferizeOpConversionPattern<FuncOp>::BufferizeOpConversionPattern;
 
   /// Performs the actual signature rewriting step.
   LogicalResult matchAndRewrite(mlir::FuncOp, ArrayRef<Value>,
                                 ConversionPatternRewriter &) const override;
 };
 
 /// Rewrites the `ReturnOp` to conform with the changed function signature.
 /// Operands that correspond to return values and their types have been set to
 /// AppendToArgumentsList are dropped. In their place, a corresponding copy
 /// operation from the operand to the target function argument is inserted.
 template <typename ReturnOpSourceTy, typename ReturnOpTargetTy,
           typename CopyOpTy>
-class BufferAssignmentReturnOpConverter
-    : public BufferAssignmentOpConversionPattern<ReturnOpSourceTy> {
+class BufferizeReturnOpConverter
+    : public BufferizeOpConversionPattern<ReturnOpSourceTy> {
 public:
-  using BufferAssignmentOpConversionPattern<
-      ReturnOpSourceTy>::BufferAssignmentOpConversionPattern;
+  using BufferizeOpConversionPattern<
+      ReturnOpSourceTy>::BufferizeOpConversionPattern;
 
   /// Performs the actual return-op conversion step.
   LogicalResult
   matchAndRewrite(ReturnOpSourceTy returnOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     Location loc = returnOp.getLoc();
 
     // Split the operands depending on whether they need a copy operation or
     // they remain as operands of the return operation. If an operand is
     // decomposable and a decompose callback function has been provided by the
     // user, it will be unpacked.
     SmallVector<Value, 2> newOperands, needCopyOperands;
     OpBuilder builder(returnOp);
     for (auto operand : llvm::enumerate(operands)) {
       SmallVector<Value, 2> values;
       this->converter.tryDecomposeValue(builder, loc, operand.value().getType(),
                                         operand.value(), values);
       Type type = returnOp.getOperand(operand.index()).getType();
       SmallVector<Type, 2> originTypes;
       this->converter.tryDecomposeType(type, originTypes);
       for (auto value : llvm::enumerate(values)) {
         Type origin = originTypes[value.index()];
         Type converted = value.value().getType();
         auto kind = this->converter.getResultConversionKind(origin, converted);
-        if (kind == BufferAssignmentTypeConverter::KeepAsFunctionResult)
+        if (kind == BufferizeTypeConverter::KeepAsFunctionResult)
           newOperands.push_back(value.value());
         else
-          // kind = BufferAssignmentTypeConverter::AppendToArgumentsList
+          // kind = BufferizeTypeConverter::AppendToArgumentsList
           needCopyOperands.push_back(value.value());
       }
     }
 
     // Insert Copy operations instead for the operands that have been removed
     // from operand list and appended to the function arguments list.
     Block &entryBlock = returnOp.getParentRegion()->front();
     unsigned numFuncArgs = entryBlock.getNumArguments();
matchAndRewrite(ReturnOpSourceTy returnOp, ArrayRef<Value> operands,
     }
     rewriter.replaceOpWithNewOp<ReturnOpTargetTy>(returnOp, newOperands);
     return success();
   }
 };
 
 /// Rewrites the `CallOp` to match its operands and results with the signature
 /// of the callee after rewriting the callee with
-/// BufferAssignmentFuncOpConverter.
-class BufferAssignmentCallOpConverter
-    : public BufferAssignmentOpConversionPattern<CallOp> {
+/// BufferizeFuncOpConverter.
+class BufferizeCallOpConverter : public BufferizeOpConversionPattern<CallOp> {
 public:
-  using BufferAssignmentOpConversionPattern<
-      CallOp>::BufferAssignmentOpConversionPattern;
+  using BufferizeOpConversionPattern<CallOp>::BufferizeOpConversionPattern;
 
   /// Performs the actual rewriting step.
   LogicalResult matchAndRewrite(CallOp, ArrayRef<Value>,
                                 ConversionPatternRewriter &) const override;
 };
 
 /// Populates `patterns` with the conversion patterns of buffer
 /// assignment.
 template <typename ReturnOpSourceTy, typename ReturnOpTargetTy,
           typename CopyOpTy>
-static void populateWithBufferAssignmentOpConversionPatterns(
-    MLIRContext *context, BufferAssignmentTypeConverter &converter,
+static void
+populateWithBufferizeOpConversionPatterns(MLIRContext *context,
+                                          BufferizeTypeConverter &converter,
                                           OwningRewritePatternList &patterns) {
   // clang-format off
   patterns.insert<
-    BufferAssignmentCallOpConverter,
-    BufferAssignmentFuncOpConverter,
-    BufferAssignmentReturnOpConverter
+    BufferizeCallOpConverter,
+    BufferizeFuncOpConverter,
+    BufferizeReturnOpConverter
       <ReturnOpSourceTy, ReturnOpTargetTy, CopyOpTy>
   >(context, converter);
   // clang-format on
 }
 } // end namespace mlir
 
 #endif // MLIR_TRANSFORMS_BUFFERIZE_H

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

for (auto shapeElement : llvm::enumerate(tensorType.getShape())) {
       }
     }
     resultBuffers.push_back(b.create<AllocOp>(loc, memrefType, dynOperands));
   }
   return success();
 }
 
 // Specialization for `linalg::GenericOp`.
 /// A pattern to convert Generic Linalg operations which work on tensors to
-/// use buffers. A buffer is allocated using BufferAssignmentPlacer for
-/// each operation result. BufferPlacement pass should be later used to move
+/// use buffers. BufferPlacement pass should be later used to move
 /// Alloc operations to the correct positions and insert the missing Dealloc
 /// operations in the correct places.
 static void finalizeBufferAllocation(ConversionPatternRewriter &rewriter,
                                      linalg::GenericOp genericOp,
                                      ValueRange inputs, ValueRange outputs) {
   // Generate a new linalg operation that works on buffers.
   auto newGenericOp = rewriter.create<linalg::GenericOp>(
       genericOp.getLoc(),

 namespace {
 
 /// Converts Linalg operations that work on tensor-type operands or results to
 /// work on buffers.
 struct LinalgBufferizePass : public LinalgBufferizeBase<LinalgBufferizePass> {
   void runOnOperation() override {
     MLIRContext &context = getContext();
     ConversionTarget target(context);
-    BufferAssignmentTypeConverter converter;
+    BufferizeTypeConverter converter;
 
     // Mark all Standard operations legal.
     target.addLegalDialect<StandardOpsDialect, vector::VectorDialect>();
     target.addLegalOp<ModuleOp>();
     target.addLegalOp<ModuleTerminatorOp>();
 
     // Mark all Linalg operations illegal as long as they work on tensors.
     auto isLegalOperation = [&](Operation *op) {
void runOnOperation() override {
     target.addDynamicallyLegalOp<FuncOp>([&](FuncOp funcOp) {
       return converter.isSignatureLegal(funcOp.getType()) &&
              llvm::none_of(funcOp.getType().getResults(),
                            [&](Type type) { return type.isa<MemRefType>(); }) &&
              converter.isLegal(&funcOp.getBody());
     });
 
     converter.setResultConversionKind<RankedTensorType, MemRefType>(
-        BufferAssignmentTypeConverter::AppendToArgumentsList);
+        BufferizeTypeConverter::AppendToArgumentsList);
 
     OwningRewritePatternList patterns;
     populateLinalgBufferizePatterns(&context, converter, patterns);
-    populateWithBufferAssignmentOpConversionPatterns<
-        mlir::ReturnOp, mlir::ReturnOp, linalg::CopyOp>(&context, converter,
-                                                        patterns);
+    populateWithBufferizeOpConversionPatterns<mlir::ReturnOp, mlir::ReturnOp,
+                                              linalg::CopyOp>(
+        &context, converter, patterns);
     if (failed(applyFullConversion(this->getOperation(), target, patterns)))
       this->signalPassFailure();
   }
 };
 } // end anonymous namespace
 
 std::unique_ptr<OperationPass<ModuleOp>> mlir::createLinalgBufferizePass() {
   return std::make_unique<LinalgBufferizePass>();
 }
 void mlir::linalg::populateLinalgBufferizePatterns(
-    MLIRContext *context, BufferAssignmentTypeConverter &converter,
+    MLIRContext *context, BufferizeTypeConverter &converter,
     OwningRewritePatternList &patterns) {
   patterns.insert<
       // clang-format off
       LinalgOpConverter,
       TensorCastOpConverter,
       TensorConstantOpConverter
       // clang-format on
       >(context, converter);
 }

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

 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 using namespace mlir::shape;
 
 namespace {
 // Propagate tensor to memref conversions through shape.assuming ops.
 class TypeConversionAssumingOpConverter
-    : public BufferAssignmentOpConversionPattern<shape::AssumingOp> {
+    : public BufferizeOpConversionPattern<shape::AssumingOp> {
 public:
-  using BufferAssignmentOpConversionPattern<
-      shape::AssumingOp>::BufferAssignmentOpConversionPattern;
+  using BufferizeOpConversionPattern<
+      shape::AssumingOp>::BufferizeOpConversionPattern;
 
   LogicalResult
   matchAndRewrite(shape::AssumingOp assumingOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     SmallVector<Type, 2> newResultTypes;
     newResultTypes.reserve(assumingOp.getNumResults());
     for (auto result : assumingOp.getResults()) {
       auto originalType = result.getType();
public:
   }
 };
 
 struct ShapeBufferizePass : public ShapeBufferizeBase<ShapeBufferizePass> {
   void runOnFunction() override {
     MLIRContext &ctx = getContext();
 
     OwningRewritePatternList patterns;
-    BufferAssignmentTypeConverter converter;
+    BufferizeTypeConverter converter;
     populateShapeTypeConversionPatterns(&ctx, converter, patterns);
 
     ConversionTarget target(getContext());
     auto isMemRefType = [](Type type) { return type.isa<BaseMemRefType>(); };
 
     target.addDynamicallyLegalOp<AssumingOp>([&](shape::AssumingOp op) {
       return std::all_of(op.result_type_begin(), op.result_type_end(),
                          isMemRefType);
     });
 
     if (failed(mlir::applyPartialConversion(getFunction(), target, patterns)))
       signalPassFailure();
   }
 };
 
 } // namespace
 
 /// Populates `patterns` with the conversion patterns of tensor->memref.
 //
 // TODO: Change this to work generally with any type conversions.
 void mlir::populateShapeTypeConversionPatterns(
-    MLIRContext *context, BufferAssignmentTypeConverter &converter,
+    MLIRContext *context, BufferizeTypeConverter &converter,
     OwningRewritePatternList &patterns) {
   patterns.insert<TypeConversionAssumingOpConverter>(context, converter);
 }
 
 //===----------------------------------------------------------------------===//
 // ShapeBufferizePass construction
 //===----------------------------------------------------------------------===//
 
 std::unique_ptr<FunctionPass> mlir::createShapeBufferizePass() {
   return std::make_unique<ShapeBufferizePass>();
 }

mlir/lib/Transforms/Bufferize.cpp

 //===- Bufferize.cpp - Bufferization utilities ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Transforms/Bufferize.h"
 #include "mlir/IR/Operation.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
-// BufferAssignmentTypeConverter
+// BufferizeTypeConverter
 //===----------------------------------------------------------------------===//
 
-/// Registers conversions into BufferAssignmentTypeConverter
-BufferAssignmentTypeConverter::BufferAssignmentTypeConverter() {
+/// Registers conversions into BufferizeTypeConverter
+BufferizeTypeConverter::BufferizeTypeConverter() {
   // Keep all types unchanged.
   addConversion([](Type type) { return type; });
   // Convert RankedTensorType to MemRefType.
   addConversion([](RankedTensorType type) {
     return (Type)MemRefType::get(type.getShape(), type.getElementType());
   });
   // Convert UnrankedTensorType to UnrankedMemRefType.
   addConversion([](UnrankedTensorType type) {
     return (Type)UnrankedMemRefType::get(type.getElementType(), 0);
   });
 }
 
 /// This method tries to decompose a value of a certain type using provided
 /// decompose callback functions. If it is unable to do so, the original value
 /// is returned.
-void BufferAssignmentTypeConverter::tryDecomposeValue(
+void BufferizeTypeConverter::tryDecomposeValue(
     OpBuilder &builder, Location loc, Type type, Value value,
     SmallVectorImpl<Value> &results) {
   for (auto conversion : decomposeValueConversions)
     if (conversion(builder, loc, type, value, results) != llvm::None)
       return;
   results.push_back(value);
 }
 
 /// This method tries to decompose a type using provided decompose callback
 /// functions. If it is unable to do so, the original type is returned.
-void BufferAssignmentTypeConverter::tryDecomposeType(
-    Type type, SmallVectorImpl<Type> &types) {
+void BufferizeTypeConverter::tryDecomposeType(Type type,
+                                              SmallVectorImpl<Type> &types) {
   for (auto conversion : decomposeTypeConversions)
     if (conversion(type, types) != llvm::None)
       return;
   types.push_back(type);
 }
 
 /// This method returns ResultConversionKind for the input type.
-BufferAssignmentTypeConverter::ResultConversionKind
-BufferAssignmentTypeConverter::getResultConversionKind(Type origin,
-                                                       Type converted) {
+BufferizeTypeConverter::ResultConversionKind
+BufferizeTypeConverter::getResultConversionKind(Type origin, Type converted) {
   for (auto conversion : resultTypeConversions) {
     auto res = conversion(origin, converted);
     if (res != llvm::None)
       return res.getValue();
   }
   return KeepAsFunctionResult;
 }
 
 //===----------------------------------------------------------------------===//
-// BufferAssignmentFuncOpConverter
+// BufferizeFuncOpConverter
 //===----------------------------------------------------------------------===//
 
 /// Performs the actual function signature rewriting step.
-LogicalResult BufferAssignmentFuncOpConverter::matchAndRewrite(
+LogicalResult BufferizeFuncOpConverter::matchAndRewrite(
     mlir::FuncOp funcOp, ArrayRef<Value> operands,
     ConversionPatternRewriter &rewriter) const {
   auto funcType = funcOp.getType();
 
   // Convert function arguments using the provided TypeConverter.
   TypeConverter::SignatureConversion conversion(funcType.getNumInputs());
   for (auto argType : llvm::enumerate(funcType.getInputs())) {
     SmallVector<Type, 2> decomposedTypes, convertedTypes;
     converter.tryDecomposeType(argType.value(), decomposedTypes);
     converter.convertTypes(decomposedTypes, convertedTypes);
     conversion.addInputs(argType.index(), convertedTypes);
   }
 
   // Convert the result types of the function.
   SmallVector<Type, 2> newResultTypes;
   newResultTypes.reserve(funcOp.getNumResults());
   for (Type resultType : funcType.getResults()) {
     SmallVector<Type, 2> originTypes;
     converter.tryDecomposeType(resultType, originTypes);
     for (auto origin : originTypes) {
       Type converted = converter.convertType(origin);
       auto kind = converter.getResultConversionKind(origin, converted);
-      if (kind == BufferAssignmentTypeConverter::AppendToArgumentsList)
+      if (kind == BufferizeTypeConverter::AppendToArgumentsList)
         conversion.addInputs(converted);
       else
-        // kind = BufferAssignmentTypeConverter::KeepAsFunctionResult
+        // kind = BufferizeTypeConverter::KeepAsFunctionResult
         newResultTypes.push_back(converted);
     }
   }
 
   if (failed(rewriter.convertRegionTypes(&funcOp.getBody(), converter,
                                          &conversion)))
     return failure();
 
   // Update the signature of the function.
   rewriter.updateRootInPlace(funcOp, [&] {
     funcOp.setType(rewriter.getFunctionType(conversion.getConvertedTypes(),
                                             newResultTypes));
   });
   return success();
 }
 
 //===----------------------------------------------------------------------===//
-// BufferAssignmentCallOpConverter
+// BufferizeCallOpConverter
 //===----------------------------------------------------------------------===//
 
 namespace {
 // This class represents a mapping from a result to a list of values and some
 // results that have not yet constructed. Instead, the indices of these
 // results in the operation that will be constructed are known. They will be
 // replaced with the actual values when they are available. The order of
 // adding to this mapping is important.
private:
   SmallVector<std::pair<unsigned, Value>, 2> toValuesMapping;
 
   /// Containing the indices of result values with their inserting orders.
   SmallVector<std::pair<unsigned, unsigned>, 2> toIndicesMapping;
 };
 } // namespace
 
 /// Performs the actual rewriting step.
-LogicalResult BufferAssignmentCallOpConverter::matchAndRewrite(
+LogicalResult BufferizeCallOpConverter::matchAndRewrite(
     CallOp callOp, ArrayRef<Value> operands,
     ConversionPatternRewriter &rewriter) const {
 
   Location loc = callOp.getLoc();
   OpBuilder builder(callOp);
   SmallVector<Value, 2> newOperands;
 
   // TODO: if the CallOp references a FuncOp that only has a declaration (e.g.
LogicalResult BufferizeCallOpConverter::matchAndRewrite(
   mappings.resize(callOp.getNumResults());
   for (auto result : llvm::enumerate(callOp.getResults())) {
     SmallVector<Type, 2> originTypes;
     converter.tryDecomposeType(result.value().getType(), originTypes);
     auto &resultMapping = mappings[result.index()];
     for (Type origin : originTypes) {
       Type converted = converter.convertType(origin);
       auto kind = converter.getResultConversionKind(origin, converted);
-      if (kind == BufferAssignmentTypeConverter::KeepAsFunctionResult) {
+      if (kind == BufferizeTypeConverter::KeepAsFunctionResult) {
         newResultTypes.push_back(converted);
         // The result value is not yet available. Its index is kept and it is
         // replaced with the actual value of the new `CallOp` later.
         resultMapping.addMapping(newResultTypes.size() - 1);
       } else {
-        // kind = BufferAssignmentTypeConverter::AppendToArgumentsList
+        // kind = BufferizeTypeConverter::AppendToArgumentsList
         MemRefType memref = converted.dyn_cast<MemRefType>();
         if (!memref)
           return callOp.emitError("Cannot allocate for a non-Memref type");
         Value alloc = rewriter.create<AllocOp>(loc, memref);
         newOperands.push_back(alloc);
         resultMapping.addMapping(alloc);
       }
     }

mlir/test/Transforms/buffer-placement-preparation.mlir

 //      CHECK: br ^[[EXIT_BLOCK:.*]](%[[ARG0]] : [[ARG0_TYPE]])
 //      CHECK: br ^[[EXIT_BLOCK]](%[[ARG0]] : [[ARG0_TYPE]])
 //      CHECK: ^[[EXIT_BLOCK]](%{{.*}}: [[ARG0_TYPE]])
 // CHECK-NEXT: linalg.copy(%[[ARG1]], %[[RESULT]])
 // CHECK-NEXT: return
 
 // -----
 
-// Test Case: Simple case for checking if BufferAssignmentPlacer creates AllocOps right before GenericOps.
+// Test Case: Simple case for checking if BufferizePlacer creates AllocOps right before GenericOps.
 
 #map0 = affine_map<(d0) -> (d0)>
 
 // CHECK-LABEL: func @compute_allocs_position_simple
 func @compute_allocs_position_simple(%cond: i1, %arg0: tensor<2xf32>) -> tensor<2xf32>{
     %0 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]}
       ins(%arg0 : tensor<2xf32>) {
     ^bb0(%gen1_arg0: f32):

 //      CHECK: (%{{.*}}: {{.*}}, %[[ARG0:.*]]: memref<2xf32>,
 // CHECK-NEXT: %[[FIRST_ALLOC:.*]] = alloc()
 // CHECK-NEXT: linalg.generic {{.*}} ins(%[[ARG0]]{{.*}} outs(%[[FIRST_ALLOC]]
 //      CHECK: %[[SECOND_ALLOC:.*]] = alloc()
 // CHECK-NEXT: linalg.generic {{.*}} ins(%[[FIRST_ALLOC]]{{.*}} outs(%[[SECOND_ALLOC]]
 
 // -----
 
-// Test Case: if-else case for checking if BufferAssignmentPlacer creates AllocOps right before GenericOps.
+// Test Case: if-else case for checking if BufferizePlacer creates AllocOps right before GenericOps.
 
 #map0 = affine_map<(d0) -> (d0)>
 
 // CHECK-LABEL: func @compute_allocs_position
 func @compute_allocs_position(%cond: i1, %arg0: tensor<2xf32>) -> tensor<2xf32>{
     %0 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]}
       ins(%arg0 : tensor<2xf32>) {
     ^bb0(%gen1_arg0: f32):

 // CHECK-NEXT: ^[[EXIT]]
 // CHECK-NEXT: %[[ALLOC6:.*]] = alloc()
 // CHECK-NEXT: linalg.generic {{.*}} ins(%[[ARG0]]{{.*}} outs(%[[ALLOC6]]
 //      CHECK: %[[ALLOC7:.*]] = alloc()
 // CHECK-NEXT: linalg.generic {{.*}} ins(%[[ALLOC6]]{{.*}} outs(%[[ALLOC7]]
 
 // -----
 
-// Test case: Checking BufferAssignmentCallOpConverter and
-// BufferAssignmentFuncOpConverter and BufferAssignmentReturnOpConverter all
+// Test case: Checking BufferizeCallOpConverter and
+// BufferizeFuncOpConverter and BufferizeReturnOpConverter all
 // together. The signature of `callee` after signature conversion would be:
 
 // func @callee(%arg0: memref<5xf32>,%arg1: memref<5xf32>) -> ()
 
 // The operands and results of caller and return operations must be matched
 // respectively.
 
 #map0 = affine_map<(d0) -> (d0)>

 // CHECK: call @callee(%[[CALLER_ARG]], %[[FIRST_ALLOC]])
 // CHECK: %[[SECOND_ALLOC:.*]] = alloc()
 // CHECK: call @callee(%[[FIRST_ALLOC]], %[[SECOND_ALLOC]])
 // CHECK: linalg.copy(%[[SECOND_ALLOC]], %[[CALLER_RESULT]])
 // CHECK: return
 
 // -----
 
-// Test case: Checking BufferAssignmentCallOpConverter and
-// BufferAssignmentFuncOpConverter and BufferAssignmentReturnOpConverter all
+// Test case: Checking BufferizeCallOpConverter and
+// BufferizeFuncOpConverter and BufferizeReturnOpConverter all
 // together on functions that also have memref typed results. The signature of
 // `callee` after signature conversion would be:
 
 // func @callee(%arg0: memref<5xf32>,%arg1: memref<5xf32>)-> memref<2xf32>
 
 // where %arg0 is the input and %arg1 is the output buffer and the original memref
 // type result remain as the function result. Then, the rewriter should match the
 // caller's signature with the callee. Thus, two buffers will be allocated instead

mlir/test/lib/Transforms/TestBufferPlacement.cpp

 #include "mlir/IR/Operation.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/Bufferize.h"
 
 using namespace mlir;
 
 namespace {
-/// This pass tests the computeAllocPosition helper method and buffer assignment
+/// This pass tests the computeAllocPosition helper method and bufferize
 /// operation converters. Furthermore, this pass converts linalg operations on
 /// tensors to linalg operations on buffers to prepare them for the
 /// BufferPlacement pass that can be applied afterwards.
 /// `allowMemrefFunctionResults` informs the buffer placement to allow functions
 /// that have memref typed results. Buffer assignment operation converters will
 /// be adapted respectively. It will also allow memref typed results to escape
 /// from the deallocation.
 template <bool allowMemrefFunctionResults>
 struct TestBufferPlacementPreparationPass
     : mlir::PassWrapper<
           TestBufferPlacementPreparationPass<allowMemrefFunctionResults>,
           OperationPass<ModuleOp>> {
 
   /// Converts tensor-type generic linalg operations to memref ones using
-  /// buffer assignment.
+  /// bufferize.
   /// TODO: Avoid the copy-pasta by exposing the pattern from BufferPlacement.h
   /// This is limited by not wanting BufferPlacement to depend on Linalg. Fixing
   /// this probably requires an OpConversionPattern over generic Operation*. For
   /// now only RewritePattern but not ConversionPattern allow this.
 
   class GenericOpConverter
-      : public BufferAssignmentOpConversionPattern<linalg::GenericOp> {
+      : public BufferizeOpConversionPattern<linalg::GenericOp> {
   public:
-    using BufferAssignmentOpConversionPattern<
-        linalg::GenericOp>::BufferAssignmentOpConversionPattern;
+    using BufferizeOpConversionPattern<
+        linalg::GenericOp>::BufferizeOpConversionPattern;
 
     LogicalResult
     matchAndRewrite(linalg::GenericOp op, ArrayRef<Value> operands,
                     ConversionPatternRewriter &rewriter) const final {
       linalg::GenericOpAdaptor adaptor(operands,
                                        op.getOperation()->getAttrDictionary());
 
       // All inputs need to be turned into buffers first. Until then, bail out.
matchAndRewrite(linalg::GenericOp op, ArrayRef<Value> operands,
 
       // Replace the results of the old op with the new output buffers.
       rewriter.replaceOp(op, newOutputBuffers);
       return success();
     }
   };
 
   void populateTensorLinalgToBufferLinalgConversionPattern(
-      MLIRContext *context, BufferAssignmentTypeConverter &converter,
+      MLIRContext *context, BufferizeTypeConverter &converter,
       OwningRewritePatternList &patterns) {
-    populateWithBufferAssignmentOpConversionPatterns<
-        mlir::ReturnOp, mlir::ReturnOp, linalg::CopyOp>(context, converter,
-                                                        patterns);
+    populateWithBufferizeOpConversionPatterns<mlir::ReturnOp, mlir::ReturnOp,
+                                              linalg::CopyOp>(
+        context, converter, patterns);
     patterns.insert<GenericOpConverter>(context, converter);
   }
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<TestDialect>();
     registry.insert<linalg::LinalgDialect>();
   }
 
   void runOnOperation() override {
     MLIRContext &context = this->getContext();
     ConversionTarget target(context);
-    BufferAssignmentTypeConverter converter;
+    BufferizeTypeConverter converter;
 
     // Mark all Standard operations legal.
     target.addLegalDialect<StandardOpsDialect>();
     target.addLegalOp<MakeTupleOp>();
     target.addLegalOp<GetTupleElementOp>();
     target.addLegalOp<ModuleOp>();
     target.addLegalOp<ModuleTerminatorOp>();
 
void runOnOperation() override {
 
     // Mark the function whose arguments are in tensor-type illegal.
     target.addDynamicallyLegalOp<FuncOp>([&](FuncOp funcOp) {
       return converter.isSignatureLegal(funcOp.getType()) &&
              converter.isLegal(&funcOp.getBody());
     });
 
     auto kind = allowMemrefFunctionResults
-                    ? BufferAssignmentTypeConverter::KeepAsFunctionResult
-                    : BufferAssignmentTypeConverter::AppendToArgumentsList;
+                    ? BufferizeTypeConverter::KeepAsFunctionResult
+                    : BufferizeTypeConverter::AppendToArgumentsList;
     converter.setResultConversionKind<RankedTensorType, MemRefType>(kind);
     converter.setResultConversionKind<UnrankedTensorType, UnrankedMemRefType>(
         kind);
 
     converter.addDecomposeTypeConversion(
         [](TupleType tupleType, SmallVectorImpl<Type> &types) {
           tupleType.getFlattenedTypes(types);
           return success();