[mlir][IR] Move listeners to Listeners.h

[springerm]

Summary

All builder/listener classes are moved to a new header file.

Merge OpBuilder::Listener and RewriterBase::Listener into a single class: RewriteListener. This simplifies the listeners:

• ListenerBase and ListenerBase::Kind are no longer needed.
• Type checks (to see if a builder listener or a rewrite listener is attached) are no longer necessary.

This change is in preparation of adding an attachScopedListener API to OpBuilder, which is safer than exposing setListener to the user. This will require creating a RewriterBase::ForwardingListener (now ForwardingRewriteListener); having references to RewriterBase from Builders.h would be odd.

Depends On: D155599

flang/include/flang/Optimizer/Builder/FIRBuilder.h

 class BoxValue;
 
 //===----------------------------------------------------------------------===//
 // FirOpBuilder
 //===----------------------------------------------------------------------===//
 
 /// Extends the MLIR OpBuilder to provide methods for building common FIR
 /// patterns.
-class FirOpBuilder : public mlir::OpBuilder, public mlir::OpBuilder::Listener {
+class FirOpBuilder : public mlir::OpBuilder, public mlir::RewriteListener {
 public:
   explicit FirOpBuilder(mlir::Operation *op, fir::KindMapping kindMap)
       : OpBuilder{op, /*listener=*/this}, kindMap{std::move(kindMap)} {}
   explicit FirOpBuilder(mlir::OpBuilder &builder, fir::KindMapping kindMap)
-      : OpBuilder(builder), OpBuilder::Listener(), kindMap{std::move(kindMap)} {
+      : OpBuilder(builder), RewriteListener(), kindMap{std::move(kindMap)} {
     setListener(this);
   }
   explicit FirOpBuilder(mlir::OpBuilder &builder, mlir::ModuleOp mod)
-      : OpBuilder(builder), OpBuilder::Listener(),
-        kindMap{getKindMapping(mod)} {
+      : OpBuilder(builder), RewriteListener(), kindMap{getKindMapping(mod)} {
     setListener(this);
   }
 
   // The listener self-reference has to be updated in case of copy-construction.
   FirOpBuilder(const FirOpBuilder &other)
-      : OpBuilder(other), OpBuilder::Listener(), kindMap{other.kindMap},
+      : OpBuilder(other), RewriteListener(), kindMap{other.kindMap},
         fastMathFlags{other.fastMathFlags} {
     setListener(this);
   }
 
   FirOpBuilder(FirOpBuilder &&other)
-      : OpBuilder(other), OpBuilder::Listener(),
-        kindMap{std::move(other.kindMap)}, fastMathFlags{other.fastMathFlags} {
+      : OpBuilder(other), RewriteListener(), kindMap{std::move(other.kindMap)},
+        fastMathFlags{other.fastMathFlags} {
     setListener(this);
   }
 
   /// Get the current Region of the insertion point.
   mlir::Region &getRegion() { return *getBlock()->getParent(); }
 
   /// Get the current Module
   mlir::ModuleOp getModule() {

flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp

if (mlir::Operation *op = value.getDefiningOp())
     return op->getBlock() == builder.getBlock();
   return false;
 }
 
 /// This Listener allows setting both the builder and the rewriter as
 /// listeners. This is required when a pattern uses a firBuilder helper that
 /// may create illegal operations that will need to be translated and requires
 /// notifying the rewriter.
-struct HLFIRListener : public mlir::OpBuilder::Listener {
+struct HLFIRListener : public mlir::RewriteListener {
   HLFIRListener(fir::FirOpBuilder &builder,
                 mlir::ConversionPatternRewriter &rewriter)
       : builder{builder}, rewriter{rewriter} {}
   void notifyOperationInserted(mlir::Operation *op) override {
     builder.notifyOperationInserted(op);
     rewriter.notifyOperationInserted(op);
   }
   virtual void notifyBlockCreated(mlir::Block *block) override {

mlir/include/mlir/Dialect/SCF/IR/SCFOps.td

let builders = [
     OpBuilder<(ins "Value":$cond,
       CArg<"function_ref<void(OpBuilder &, Location)>",
            "buildTerminatedBody">:$thenBuilder,
       CArg<"function_ref<void(OpBuilder &, Location)>",
            "nullptr">:$elseBuilder)>,
   ];
 
   let extraClassDeclaration = [{
-    OpBuilder getThenBodyBuilder(OpBuilder::Listener *listener = nullptr) {
+    OpBuilder getThenBodyBuilder(RewriteListener *listener = nullptr) {
       Block* body = getBody(0);
       return getResults().empty() ? OpBuilder::atBlockTerminator(body, listener)
                                   : OpBuilder::atBlockEnd(body, listener);
     }
-    OpBuilder getElseBodyBuilder(OpBuilder::Listener *listener = nullptr) {
+    OpBuilder getElseBodyBuilder(RewriteListener *listener = nullptr) {
       Block* body = getBody(1);
       return getResults().empty() ? OpBuilder::atBlockTerminator(body, listener)
                                   : OpBuilder::atBlockEnd(body, listener);
     }
     Block* thenBlock();
     YieldOp thenYield();
     Block* elseBlock();
     YieldOp elseYield();

mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h

 /// surrounding regions remain accessible.
 TransformState::RegionScope TransformState::make_region_scope(Region &region) {
   return RegionScope(*this, region);
 }
 
 /// A listener that updates a TransformState based on IR modifications. This
 /// listener can be used during a greedy pattern rewrite to keep the transform
 /// state up-to-date.
-class TrackingListener : public RewriterBase::Listener,
+class TrackingListener : public RewriteListener,
                          public TransformState::Extension {
 public:
   /// Create a new TrackingListener for usage in the specified transform op.
   TrackingListener(TransformState &state, TransformOpInterface op);
 
 protected:
   /// Return a replacement payload op for the given op, which is going to be
   /// replaced with the given values. By default, if all values are defined by
protected:
   TransformOpInterface getTransformOp() const { return transformOp; }
 
 private:
   friend class TransformRewriter;
 
   void notifyOperationRemoved(Operation *op) override;
 
   void notifyOperationReplaced(Operation *op, ValueRange newValues) override;
-  using Listener::notifyOperationReplaced;
+  using RewriteListener::notifyOperationReplaced;
 
   /// The transform op in which this TrackingListener is used.
   TransformOpInterface transformOp;
 
   /// The handles that are consumed by the transform op.
   DenseSet<Value> consumedHandles;
 };
 

mlir/include/mlir/IR/Builders.h

 //===- Builders.h - Helpers for constructing MLIR Classes -------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_BUILDERS_H
 #define MLIR_IR_BUILDERS_H
 
+#include "mlir/IR/Listeners.h"
 #include "mlir/IR/OpDefinition.h"
 #include "llvm/Support/Compiler.h"
 #include <optional>
 
 namespace mlir {
 
 class AffineExpr;
 class IRMapping;

 protected:
   MLIRContext *context;
 };
 
 /// This class helps build Operations. Operations that are created are
 /// automatically inserted at an insertion point. The builder is copyable.
 class OpBuilder : public Builder {
 public:
-  struct Listener;
-
   /// Create a builder with the given context.
-  explicit OpBuilder(MLIRContext *ctx, Listener *listener = nullptr)
+  explicit OpBuilder(MLIRContext *ctx, RewriteListener *listener = nullptr)
       : Builder(ctx), listener(listener) {}
 
   /// Create a builder and set the insertion point to the start of the region.
-  explicit OpBuilder(Region *region, Listener *listener = nullptr)
+  explicit OpBuilder(Region *region, RewriteListener *listener = nullptr)
       : OpBuilder(region->getContext(), listener) {
     if (!region->empty())
       setInsertionPoint(&region->front(), region->front().begin());
   }
-  explicit OpBuilder(Region &region, Listener *listener = nullptr)
+  explicit OpBuilder(Region &region, RewriteListener *listener = nullptr)
       : OpBuilder(&region, listener) {}
 
   /// Create a builder and set insertion point to the given operation, which
   /// will cause subsequent insertions to go right before it.
-  explicit OpBuilder(Operation *op, Listener *listener = nullptr)
+  explicit OpBuilder(Operation *op, RewriteListener *listener = nullptr)
       : OpBuilder(op->getContext(), listener) {
     setInsertionPoint(op);
   }
 
   OpBuilder(Block *block, Block::iterator insertPoint,
-            Listener *listener = nullptr)
+            RewriteListener *listener = nullptr)
       : OpBuilder(block->getParent()->getContext(), listener) {
     setInsertionPoint(block, insertPoint);
   }
 
   /// Create a builder and set the insertion point to before the first operation
   /// in the block but still inside the block.
-  static OpBuilder atBlockBegin(Block *block, Listener *listener = nullptr) {
+  static OpBuilder atBlockBegin(Block *block,
+                                RewriteListener *listener = nullptr) {
     return OpBuilder(block, block->begin(), listener);
   }
 
   /// Create a builder and set the insertion point to after the last operation
   /// in the block but still inside the block.
-  static OpBuilder atBlockEnd(Block *block, Listener *listener = nullptr) {
+  static OpBuilder atBlockEnd(Block *block,
+                              RewriteListener *listener = nullptr) {
     return OpBuilder(block, block->end(), listener);
   }
 
   /// Create a builder and set the insertion point to before the block
   /// terminator.
   static OpBuilder atBlockTerminator(Block *block,
-                                     Listener *listener = nullptr) {
+                                     RewriteListener *listener = nullptr) {
     auto *terminator = block->getTerminator();
     assert(terminator != nullptr && "the block has no terminator");
     return OpBuilder(block, Block::iterator(terminator), listener);
   }
 
-  //===--------------------------------------------------------------------===//
-  // Listeners
-  //===--------------------------------------------------------------------===//
-
-  /// Base class for listeners.
-  struct ListenerBase {
-    /// The kind of listener.
-    enum class Kind {
-      /// OpBuilder::Listener or user-derived class.
-      OpBuilderListener = 0,
-
-      /// RewriterBase::Listener or user-derived class.
-      RewriterBaseListener = 1
-    };
-
-    Kind getKind() const { return kind; }
-
-  protected:
-    ListenerBase(Kind kind) : kind(kind) {}
-
-  private:
-    const Kind kind;
-  };
-
-  /// This class represents a listener that may be used to hook into various
-  /// actions within an OpBuilder.
-  struct Listener : public ListenerBase {
-    Listener() : ListenerBase(ListenerBase::Kind::OpBuilderListener) {}
-
-    virtual ~Listener() = default;
-
-    /// Notification handler for when an operation is inserted into the builder.
-    /// `op` is the operation that was inserted.
-    virtual void notifyOperationInserted(Operation *op) {}
-
-    /// Notification handler for when a block is created using the builder.
-    /// `block` is the block that was created.
-    virtual void notifyBlockCreated(Block *block) {}
-
-  protected:
-    Listener(Kind kind) : ListenerBase(kind) {}
-  };
-
   /// Sets the listener of this builder to the one provided.
-  void setListener(Listener *newListener) { listener = newListener; }
+  void setListener(RewriteListener *newListener) { listener = newListener; }
 
   /// Returns the current listener of this builder, or nullptr if this builder
   /// doesn't have a listener.
-  Listener *getListener() const { return listener; }
+  RewriteListener *getListener() const { return listener; }
 
   //===--------------------------------------------------------------------===//
   // Insertion Point Management
   //===--------------------------------------------------------------------===//
 
   /// This class represents a saved insertion point.
   class InsertPoint {
   public:
public:
   }
   template <typename OpT>
   OpT cloneWithoutRegions(OpT op) {
     return cast<OpT>(cloneWithoutRegions(*op.getOperation()));
   }
 
 protected:
   /// The optional listener for events of this builder.
-  Listener *listener;
+  RewriteListener *listener = nullptr;
 
 private:
   /// The current block this builder is inserting into.
   Block *block = nullptr;
   /// The insertion point within the block that this builder is inserting
   /// before.
   Block::iterator insertPoint;
 };
 
 } // namespace mlir
 
 #endif

mlir/include/mlir/IR/ImplicitLocOpBuilder.h

public:
   /// OpBuilder has a bunch of convenience constructors - we support them all
   /// with the additional Location.
   template <typename... T>
   ImplicitLocOpBuilder(Location loc, T &&...operands)
       : OpBuilder(std::forward<T>(operands)...), curLoc(loc) {}
 
   /// Create a builder and set the insertion point to before the first operation
   /// in the block but still inside the block.
-  static ImplicitLocOpBuilder atBlockBegin(Location loc, Block *block,
-                                           Listener *listener = nullptr) {
+  static ImplicitLocOpBuilder
+  atBlockBegin(Location loc, Block *block,
+               RewriteListener *listener = nullptr) {
     return ImplicitLocOpBuilder(loc, block, block->begin(), listener);
   }
 
   /// Create a builder and set the insertion point to after the last operation
   /// in the block but still inside the block.
   static ImplicitLocOpBuilder atBlockEnd(Location loc, Block *block,
-                                         Listener *listener = nullptr) {
+                                         RewriteListener *listener = nullptr) {
     return ImplicitLocOpBuilder(loc, block, block->end(), listener);
   }
 
   /// Create a builder and set the insertion point to before the block
   /// terminator.
-  static ImplicitLocOpBuilder atBlockTerminator(Location loc, Block *block,
-                                                Listener *listener = nullptr) {
+  static ImplicitLocOpBuilder
+  atBlockTerminator(Location loc, Block *block,
+                    RewriteListener *listener = nullptr) {
     auto *terminator = block->getTerminator();
     assert(terminator != nullptr && "the block has no terminator");
     return ImplicitLocOpBuilder(loc, block, Block::iterator(terminator),
                                 listener);
   }
 
   /// Accessors for the implied location.
   Location getLoc() const { return curLoc; }

mlir/include/mlir/IR/Listeners.h

+//===- Listeners.h - Listeners for op builders/rewriters --------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_IR_LISTENERS_H
+#define MLIR_IR_LISTENERS_H
+
+#include "mlir/IR/Operation.h"
+
+namespace mlir {
+/// This class represents a listener that may be used to hook into various
+/// actions within an OpBuilder or RewriterBase.
+struct RewriteListener {
+  virtual ~RewriteListener() = default;
+
+  /// Notification handler for when an operation is inserted into the builder.
+  /// `op` is the operation that was inserted.
+  virtual void notifyOperationInserted(Operation *op) {}
+
+  /// Notification handler for when a block is created using the builder.
+  /// `block` is the block that was created.
+  virtual void notifyBlockCreated(Block *block) {}
+
+  /// Notify the listener that the specified operation was modified in-place.
+  virtual void notifyOperationModified(Operation *op) {}
+
+  /// Notify the listener that the specified operation is about to be replaced
+  /// with another operation. This is called before the uses of the old
+  /// operation have been changed.
+  ///
+  /// By default, this function calls the "operation replaced with values"
+  /// notification.
+  virtual void notifyOperationReplaced(Operation *op, Operation *replacement) {
+    notifyOperationReplaced(op, replacement->getResults());
+  }
+
+  /// Notify the listener that the specified operation is about to be replaced
+  /// with the a range of values, potentially produced by other operations.
+  /// This is called before the uses of the operation have been changed.
+  virtual void notifyOperationReplaced(Operation *op, ValueRange replacement) {}
+
+  /// Notify the listener that the specified operation is about to be erased.
+  /// At this point, the operation has zero uses.
+  virtual void notifyOperationRemoved(Operation *op) {}
+
+  /// Notify the listener that the pattern failed to match the given
+  /// operation, and provide a callback to populate a diagnostic with the
+  /// reason why the failure occurred. This method allows for derived
+  /// listeners to optionally hook into the reason why a rewrite failed, and
+  /// display it to users.
+  virtual LogicalResult
+  notifyMatchFailure(Location loc,
+                     function_ref<void(Diagnostic &)> reasonCallback) {
+    return failure();
+  }
+};
+
+/// A listener that forwards all notifications to another listener. This
+/// struct can be used as a base to create listener chains, so that multiple
+/// listeners can be notified of IR changes.
+struct ForwardingRewriteListener : public RewriteListener {
+  ForwardingRewriteListener(RewriteListener *listener) : listener(listener) {}
+
+  void notifyOperationInserted(Operation *op) override {
+    listener->notifyOperationInserted(op);
+  }
+  void notifyBlockCreated(Block *block) override {
+    listener->notifyBlockCreated(block);
+  }
+  void notifyOperationModified(Operation *op) override {
+    listener->notifyOperationModified(op);
+  }
+  void notifyOperationReplaced(Operation *op, Operation *newOp) override {
+    listener->notifyOperationReplaced(op, newOp);
+  }
+  void notifyOperationReplaced(Operation *op, ValueRange replacement) override {
+    listener->notifyOperationReplaced(op, replacement);
+  }
+  void notifyOperationRemoved(Operation *op) override {
+    listener->notifyOperationRemoved(op);
+  }
+  LogicalResult
+  notifyMatchFailure(Location loc,
+                     function_ref<void(Diagnostic &)> reasonCallback) override {
+    return listener->notifyMatchFailure(loc, reasonCallback);
+  }
+
+private:
+  RewriteListener *listener;
+};
+} // namespace mlir
+
+#endif // MLIR_IR_LISTENERS_H

mlir/include/mlir/IR/PatternMatch.h

 
 /// This class coordinates the application of a rewrite on a set of IR,
 /// providing a way for clients to track mutations and create new operations.
 /// This class serves as a common API for IR mutation between pattern rewrites
 /// and non-pattern rewrites, and facilitates the development of shared
 /// IR transformation utilities.
 class RewriterBase : public OpBuilder {
 public:
-  struct Listener : public OpBuilder::Listener {
-    Listener()
-        : OpBuilder::Listener(ListenerBase::Kind::RewriterBaseListener) {}
-
-    /// Notify the listener that the specified operation was modified in-place.
-    virtual void notifyOperationModified(Operation *op) {}
-
-    /// Notify the listener that the specified operation is about to be replaced
-    /// with another operation. This is called before the uses of the old
-    /// operation have been changed.
-    ///
-    /// By default, this function calls the "operation replaced with values"
-    /// notification.
-    virtual void notifyOperationReplaced(Operation *op,
-                                         Operation *replacement) {
-      notifyOperationReplaced(op, replacement->getResults());
-    }
-
-    /// Notify the listener that the specified operation is about to be replaced
-    /// with the a range of values, potentially produced by other operations.
-    /// This is called before the uses of the operation have been changed.
-    virtual void notifyOperationReplaced(Operation *op,
-                                         ValueRange replacement) {}
-
-    /// Notify the listener that the specified operation is about to be erased.
-    /// At this point, the operation has zero uses.
-    virtual void notifyOperationRemoved(Operation *op) {}
-
-    /// Notify the listener that the pattern failed to match the given
-    /// operation, and provide a callback to populate a diagnostic with the
-    /// reason why the failure occurred. This method allows for derived
-    /// listeners to optionally hook into the reason why a rewrite failed, and
-    /// display it to users.
-    virtual LogicalResult
-    notifyMatchFailure(Location loc,
-                       function_ref<void(Diagnostic &)> reasonCallback) {
-      return failure();
-    }
-
-    static bool classof(const OpBuilder::Listener *base);
-  };
-
-  /// A listener that forwards all notifications to another listener. This
-  /// struct can be used as a base to create listener chains, so that multiple
-  /// listeners can be notified of IR changes.
-  struct ForwardingListener : public RewriterBase::Listener {
-    ForwardingListener(OpBuilder::Listener *listener) : listener(listener) {}
-
-    void notifyOperationInserted(Operation *op) override {
-      listener->notifyOperationInserted(op);
-    }
-    void notifyBlockCreated(Block *block) override {
-      listener->notifyBlockCreated(block);
-    }
-    void notifyOperationModified(Operation *op) override {
-      if (auto *rewriteListener = dyn_cast<RewriterBase::Listener>(listener))
-        rewriteListener->notifyOperationModified(op);
-    }
-    void notifyOperationReplaced(Operation *op, Operation *newOp) override {
-      if (auto *rewriteListener = dyn_cast<RewriterBase::Listener>(listener))
-        rewriteListener->notifyOperationReplaced(op, newOp);
-    }
-    void notifyOperationReplaced(Operation *op,
-                                 ValueRange replacement) override {
-      if (auto *rewriteListener = dyn_cast<RewriterBase::Listener>(listener))
-        rewriteListener->notifyOperationReplaced(op, replacement);
-    }
-    void notifyOperationRemoved(Operation *op) override {
-      if (auto *rewriteListener = dyn_cast<RewriterBase::Listener>(listener))
-        rewriteListener->notifyOperationRemoved(op);
-    }
-    LogicalResult notifyMatchFailure(
-        Location loc,
-        function_ref<void(Diagnostic &)> reasonCallback) override {
-      if (auto *rewriteListener = dyn_cast<RewriterBase::Listener>(listener))
-        return rewriteListener->notifyMatchFailure(loc, reasonCallback);
-      return failure();
-    }
-
-  private:
-    OpBuilder::Listener *listener;
-  };
-
   /// Move the blocks that belong to "region" before the given position in
   /// another region "parent". The two regions must be different. The caller
   /// is responsible for creating or updating the operation transferring flow
   /// of control to the region and passing it the correct block arguments.
   virtual void inlineRegionBefore(Region &region, Region &parent,
                                   Region::iterator before);
   void inlineRegionBefore(Region &region, Block *before);
 
public:
   /// a match failure, and provide a callback to populate a diagnostic with the
   /// reason why the failure occurred. This method allows for derived rewriters
   /// to optionally hook into the reason why a rewrite failed, and display it to
   /// users.
   template <typename CallbackT>
   std::enable_if_t<!std::is_convertible<CallbackT, Twine>::value, LogicalResult>
   notifyMatchFailure(Location loc, CallbackT &&reasonCallback) {
 #ifndef NDEBUG
-    if (auto *rewriteListener = dyn_cast_if_present<Listener>(listener))
-      return rewriteListener->notifyMatchFailure(
+    if (listener)
+      return listener->notifyMatchFailure(
           loc, function_ref<void(Diagnostic &)>(reasonCallback));
     return failure();
 #else
     return failure();
 #endif
   }
   template <typename CallbackT>
   std::enable_if_t<!std::is_convertible<CallbackT, Twine>::value, LogicalResult>
   notifyMatchFailure(Operation *op, CallbackT &&reasonCallback) {
-    if (auto *rewriteListener = dyn_cast_if_present<Listener>(listener))
-      return rewriteListener->notifyMatchFailure(
+    if (listener)
+      return listener->notifyMatchFailure(
           op->getLoc(), function_ref<void(Diagnostic &)>(reasonCallback));
     return failure();
   }
   template <typename ArgT>
   LogicalResult notifyMatchFailure(ArgT &&arg, const Twine &msg) {
     return notifyMatchFailure(std::forward<ArgT>(arg),
                               [&](Diagnostic &diag) { diag << msg; });
   }
   template <typename ArgT>
   LogicalResult notifyMatchFailure(ArgT &&arg, const char *msg) {
     return notifyMatchFailure(std::forward<ArgT>(arg), Twine(msg));
   }
 
 protected:
   /// Initialize the builder.
-  explicit RewriterBase(MLIRContext *ctx,
-                        OpBuilder::Listener *listener = nullptr)
+  explicit RewriterBase(MLIRContext *ctx, RewriteListener *listener = nullptr)
       : OpBuilder(ctx, listener) {}
   explicit RewriterBase(const OpBuilder &otherBuilder)
       : OpBuilder(otherBuilder) {}
   virtual ~RewriterBase();
 
 private:
   void operator=(const RewriterBase &) = delete;
   RewriterBase(const RewriterBase &) = delete;
 };
 
 //===----------------------------------------------------------------------===//
 // IRRewriter
 //===----------------------------------------------------------------------===//
 
 /// This class coordinates rewriting a piece of IR outside of a pattern rewrite,
 /// providing a way to keep track of the mutations made to the IR. This class
 /// should only be used in situations where another `RewriterBase` instance,
 /// such as a `PatternRewriter`, is not available.
 class IRRewriter : public RewriterBase {
 public:
-  explicit IRRewriter(MLIRContext *ctx, OpBuilder::Listener *listener = nullptr)
+  explicit IRRewriter(MLIRContext *ctx, RewriteListener *listener = nullptr)
       : RewriterBase(ctx, listener) {}
   explicit IRRewriter(const OpBuilder &builder) : RewriterBase(builder) {}
 };
 
 //===----------------------------------------------------------------------===//
 // PatternRewriter
 //===----------------------------------------------------------------------===//
 

mlir/include/mlir/Transforms/DialectConversion.h

 namespace detail {
 struct ConversionPatternRewriterImpl;
 } // namespace detail
 
 /// This class implements a pattern rewriter for use with ConversionPatterns. It
 /// extends the base PatternRewriter and provides special conversion specific
 /// hooks.
 class ConversionPatternRewriter final : public PatternRewriter,
-                                        public RewriterBase::Listener {
+                                        public RewriteListener {
 public:
   explicit ConversionPatternRewriter(MLIRContext *ctx);
   ~ConversionPatternRewriter() override;
 
   /// Apply a signature conversion to the entry block of the given region. This
   /// replaces the entry block with a new block containing the updated
   /// signature. The new entry block to the region is returned for convenience.
   ///

mlir/include/mlir/Transforms/FoldUtils.h

 //===--------------------------------------------------------------------===//
 // OperationFolder
 //===--------------------------------------------------------------------===//
 
 /// A utility class for folding operations, and unifying duplicated constants
 /// generated along the way.
 class OperationFolder {
 public:
-  OperationFolder(MLIRContext *ctx, OpBuilder::Listener *listener = nullptr)
+  OperationFolder(MLIRContext *ctx, RewriteListener *listener = nullptr)
       : interfaces(ctx), rewriter(ctx, listener) {}
 
   /// Tries to perform folding on the given `op`, including unifying
   /// deduplicated constants. If successful, replaces `op`'s uses with
   /// folded results, and returns success. If the op was completely folded it is
   /// erased. If it is just updated in place, `inPlaceUpdate` is set to true.
   LogicalResult tryToFold(Operation *op, bool *inPlaceUpdate = nullptr);
 

mlir/include/mlir/Transforms/GreedyPatternRewriteDriver.h

public:
   ///   were on the worklist at the very beginning) and newly created ops are
   ///   enqueued. All other ops are excluded.
   /// * GreedyRewriteStrictness::ExistingOps: Only pre-existing ops (that were
   ///   were on the worklist at the very beginning) enqueued. All other ops are
   ///   excluded.
   GreedyRewriteStrictness strictMode = GreedyRewriteStrictness::AnyOp;
 
   /// An optional listener that should be notified about IR modifications.
-  RewriterBase::Listener *listener = nullptr;
+  RewriteListener *listener = nullptr;
 };
 
 //===----------------------------------------------------------------------===//
 // applyPatternsGreedily
 //===----------------------------------------------------------------------===//
 
 /// Rewrite ops in the given region, which must be isolated from above, by
 /// repeatedly applying the highest benefit patterns in a greedy work-list

mlir/include/mlir/Transforms/OneToNTypeConversion.h

 };
 
 /// Specialization of `PatternRewriter` that `OneToNConversionPattern`s use. The
 /// class provides additional rewrite methods that are specific to 1:N type
 /// conversions.
 class OneToNPatternRewriter : public PatternRewriter {
 public:
   OneToNPatternRewriter(MLIRContext *context,
-                        OpBuilder::Listener *listener = nullptr)
+                        RewriteListener *listener = nullptr)
       : PatternRewriter(context, listener) {}
 
   /// Replaces the results of the operation with the specified list of values
   /// mapped back to the original types as specified in the provided type
   /// mapping. That type mapping must match the replaced op (i.e., the original
   /// types must be the same as the result types of the op) and the new values
   /// (i.e., the converted types must be the same as the types of the new
   /// values).

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

mlir::affine::makeComposedFoldedAffineApply(OpBuilder &b, Location loc,
   SmallVector<Attribute> constOperands(applyOp->getNumOperands());
   for (unsigned i = 0, e = constOperands.size(); i != e; ++i)
     matchPattern(applyOp->getOperand(i), m_Constant(&constOperands[i]));
 
   // Try to fold the operation.
   SmallVector<OpFoldResult> foldResults;
   if (failed(applyOp->fold(constOperands, foldResults)) ||
       foldResults.empty()) {
-    if (OpBuilder::Listener *listener = b.getListener())
+    if (RewriteListener *listener = b.getListener())
       listener->notifyOperationInserted(applyOp);
     return applyOp.getResult();
   }
 
   applyOp->erase();
   assert(foldResults.size() == 1 && "expected 1 folded result");
   return foldResults.front();
 }
static OpFoldResult makeComposedFoldedMinMax(OpBuilder &b, Location loc,
   SmallVector<Attribute> constOperands(minMaxOp->getNumOperands());
   for (unsigned i = 0, e = constOperands.size(); i != e; ++i)
     matchPattern(minMaxOp->getOperand(i), m_Constant(&constOperands[i]));
 
   // Try to fold the operation.
   SmallVector<OpFoldResult> foldResults;
   if (failed(minMaxOp->fold(constOperands, foldResults)) ||
       foldResults.empty()) {
-    if (OpBuilder::Listener *listener = b.getListener())
+    if (RewriteListener *listener = b.getListener())
       listener->notifyOperationInserted(minMaxOp);
     return minMaxOp.getResult();
   }
 
   minMaxOp->erase();
   assert(foldResults.size() == 1 && "expected 1 folded result");
   return foldResults.front();
 }

mlir/lib/Dialect/Affine/TransformOps/AffineTransformOps.cpp

SimplifyBoundedAffineOpsOp::apply(transform::TransformRewriter &rewriter,
   // Canonicalization patterns are needed so that affine.apply ops are composed
   // with the remaining affine.min/max ops.
   AffineMaxOp::getCanonicalizationPatterns(patterns, getContext());
   AffineMinOp::getCanonicalizationPatterns(patterns, getContext());
   patterns.insert<SimplifyAffineMinMaxOp<AffineMinOp>,
                   SimplifyAffineMinMaxOp<AffineMaxOp>>(getContext(), cstr);
   FrozenRewritePatternSet frozenPatterns(std::move(patterns));
   GreedyRewriteConfig config;
-  config.listener =
-      static_cast<RewriterBase::Listener *>(rewriter.getListener());
+  config.listener = rewriter.getListener();
   config.strictMode = GreedyRewriteStrictness::ExistingAndNewOps;
   // Apply the simplification pattern to a fixpoint.
   if (failed(applyOpPatternsAndFold(targets, frozenPatterns, config))) {
     auto diag = emitDefiniteFailure()
                 << "affine.min/max simplification did not converge";
     return diag;
   }
   return DiagnosedSilenceableFailure::success();

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

static bool hasTensorSemantics(Operation *op) {
 
   bool hasTensorResult = any_of(op->getResultTypes(), isaTensor);
   bool hasTensorOperand = any_of(op->getOperandTypes(), isaTensor);
   return hasTensorResult || hasTensorOperand;
 }
 
 namespace {
 /// A rewriter that keeps track of extra information during bufferization.
-class BufferizationRewriter : public IRRewriter, public RewriterBase::Listener {
+class BufferizationRewriter : public IRRewriter, public RewriteListener {
 public:
   BufferizationRewriter(MLIRContext *ctx, DenseSet<Operation *> &erasedOps,
                         DenseSet<Operation *> &toMemrefOps,
                         SmallVector<Operation *> &worklist,
                         const BufferizationOptions &options,
                         const OpFilter *opFilter,
                         BufferizationStatistics *statistics)
       : IRRewriter(ctx), erasedOps(erasedOps), toMemrefOps(toMemrefOps),

mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp

void transform::BufferizeToAllocationOp::build(OpBuilder &b,
   resultTypes.push_back(b.getType<transform::AnyOpType>());
   return build(b, result,
                /*resultTypes=*/resultTypes,
                /*target=*/target,
                /*memorySpace=*/b.getI64IntegerAttr(memorySpace));
 }
 
 namespace {
-class NewOpsListener : public RewriterBase::ForwardingListener {
+class NewOpsListener : public ForwardingRewriteListener {
 public:
-  using RewriterBase::ForwardingListener::ForwardingListener;
+  using ForwardingRewriteListener::ForwardingRewriteListener;
 
   SmallVector<Operation *> getNewOps() const {
     return SmallVector<Operation *>(newOps.begin(), newOps.end());
   }
 
 private:
   void notifyOperationInserted(Operation *op) override {
-    ForwardingListener::notifyOperationInserted(op);
+    ForwardingRewriteListener::notifyOperationInserted(op);
     auto inserted = newOps.insert(op);
     (void)inserted;
     assert(inserted.second && "expected newly created op");
   }
 
   void notifyOperationRemoved(Operation *op) override {
-    ForwardingListener::notifyOperationRemoved(op);
+    ForwardingRewriteListener::notifyOperationRemoved(op);
     op->walk([&](Operation *op) { newOps.erase(op); });
   }
 
   DenseSet<Operation *> newOps;
 };
 } // namespace
 
 DiagnosedSilenceableFailure transform::BufferizeToAllocationOp::apply(
     transform::TransformRewriter &rewriter,
     transform::TransformResults &results, transform::TransformState &state) {
   // Attach listener to keep track of newly created ops.
-  OpBuilder::Listener *previousListener = rewriter.getListener();
+  RewriteListener *previousListener = rewriter.getListener();
   auto resetListener =
       llvm::make_scope_exit([&]() { rewriter.setListener(previousListener); });
   NewOpsListener newOpsListener(previousListener);
   rewriter.setListener(&newOpsListener);
 
   linalg::BufferizeToAllocationOptions options;
   if (getMemcpyOp() == "memref.tensor_store") {
     options.memcpyOp =

mlir/lib/Dialect/Transform/IR/TransformOps.cpp

if (!getRegion().empty()) {
     for (Operation &op : getRegion().front()) {
       cast<transform::PatternDescriptorOpInterface>(&op).populatePatterns(
           patterns);
     }
   }
 
   // Configure the GreedyPatternRewriteDriver.
   GreedyRewriteConfig config;
-  config.listener =
-      static_cast<RewriterBase::Listener *>(rewriter.getListener());
+  config.listener = rewriter.getListener();
 
   LogicalResult result = failure();
   if (target->hasTrait<OpTrait::IsIsolatedFromAbove>()) {
     // Op is isolated from above. Apply patterns and also perform region
     // simplification.
     result = applyPatternsAndFoldGreedily(target, std::move(patterns), config);
   } else {
     // Manually gather list of ops because the other GreedyPatternRewriteDriver

mlir/lib/IR/PatternMatch.cpp

void PDLPatternModule::registerRewriteFunction(StringRef name,
   // rewrite.
   rewriteFunctions.try_emplace(name, std::move(rewriteFn));
 }
 
 //===----------------------------------------------------------------------===//
 // RewriterBase
 //===----------------------------------------------------------------------===//
 
-bool RewriterBase::Listener::classof(const OpBuilder::Listener *base) {
-  return base->getKind() == OpBuilder::ListenerBase::Kind::RewriterBaseListener;
-}
-
 RewriterBase::~RewriterBase() {
   // Out of line to provide a vtable anchor for the class.
 }
 
 /// This method replaces the uses of the results of `op` with the values in
 /// `newValues` when the provided `functor` returns true for a specific use.
 /// The number of values in `newValues` is required to match the number of
 /// results of `op`.
 void RewriterBase::replaceOpWithIf(
     Operation *op, ValueRange newValues, bool *allUsesReplaced,
     llvm::unique_function<bool(OpOperand &) const> functor) {
   assert(op->getNumResults() == newValues.size() &&
          "incorrect number of values to replace operation");
 
   // Notify the listener that we're about to replace this op.
-  if (auto *rewriteListener = dyn_cast_if_present<Listener>(listener))
-    rewriteListener->notifyOperationReplaced(op, newValues);
+  if (listener)
+    listener->notifyOperationReplaced(op, newValues);
 
   // Replace each use of the results when the functor is true.
   bool replacedAllUses = true;
   for (auto it : llvm::zip(op->getResults(), newValues)) {
     replaceUsesWithIf(std::get<0>(it), std::get<1>(it), functor);
     replacedAllUses &= std::get<0>(it).use_empty();
   }
   if (allUsesReplaced)

 /// This method replaces the results of the operation with the specified list of
 /// values. The number of provided values must match the number of results of
 /// the operation. The replaced op is erased.
 void RewriterBase::replaceOp(Operation *op, ValueRange newValues) {
   assert(op->getNumResults() == newValues.size() &&
          "incorrect # of replacement values");
 
   // Notify the listener that we're about to replace this op.
-  if (auto *rewriteListener = dyn_cast_if_present<Listener>(listener))
-    rewriteListener->notifyOperationReplaced(op, newValues);
+  if (listener)
+    listener->notifyOperationReplaced(op, newValues);
 
   // Replace results one-by-one. Also notifies the listener of modifications.
   for (auto it : llvm::zip(op->getResults(), newValues))
     replaceAllUsesWith(std::get<0>(it), std::get<1>(it));
 
   // Erase the op.
   eraseOp(op);
 }
 
 /// This method replaces the results of the operation with the specified new op
 /// (replacement). The number of results of the two operations must match. The
 /// replaced op is erased.
 void RewriterBase::replaceOp(Operation *op, Operation *newOp) {
   assert(op && newOp && "expected non-null op");
   assert(op->getNumResults() == newOp->getNumResults() &&
          "ops have different number of results");
 
   // Notify the listener that we're about to replace this op.
-  if (auto *rewriteListener = dyn_cast_if_present<Listener>(listener))
-    rewriteListener->notifyOperationReplaced(op, newOp);
+  if (listener)
+    listener->notifyOperationReplaced(op, newOp);
 
   // Replace results one-by-one. Also notifies the listener of modifications.
   for (auto it : llvm::zip(op->getResults(), newOp->getResults()))
     replaceAllUsesWith(std::get<0>(it), std::get<1>(it));
 
   // Erase the old op.
   eraseOp(op);
 }
 
 /// This method erases an operation that is known to have no uses. The uses of
 /// the given operation *must* be known to be dead.
 void RewriterBase::eraseOp(Operation *op) {
   assert(op->use_empty() && "expected 'op' to have no uses");
-  if (auto *rewriteListener = dyn_cast_if_present<Listener>(listener))
-    rewriteListener->notifyOperationRemoved(op);
+  if (listener)
+    listener->notifyOperationRemoved(op);
   op->erase();
 }
 
 void RewriterBase::eraseBlock(Block *block) {
   for (auto &op : llvm::make_early_inc_range(llvm::reverse(*block))) {
     assert(op.use_empty() && "expected 'op' to have no uses");
     eraseOp(&op);
   }
   block->erase();
 }
 
 void RewriterBase::finalizeRootUpdate(Operation *op) {
   // Notify the listener that the operation was modified.
-  if (auto *rewriteListener = dyn_cast_if_present<Listener>(listener))
-    rewriteListener->notifyOperationModified(op);
+  if (listener)
+    listener->notifyOperationModified(op);
 }
 
 /// Find uses of `from` and replace them with `to` if the `functor` returns
 /// true. It also marks every modified uses and notifies the rewriter that an
 /// in-place operation modification is about to happen.
 void RewriterBase::replaceUsesWithIf(Value from, Value to,
                                      function_ref<bool(OpOperand &)> functor) {
   for (OpOperand &operand : llvm::make_early_inc_range(from.getUses())) {

mlir/lib/Transforms/CSE.cpp

void CSEDriver::replaceUsesAndDelete(ScopedMapTy &knownValues, Operation *op,
                                      Operation *existing,
                                      bool hasSSADominance) {
   // If we find one then replace all uses of the current operation with the
   // existing one and mark it for deletion. We can only replace an operand in
   // an operation if it has not been visited yet.
   if (hasSSADominance) {
     // If the region has SSA dominance, then we are guaranteed to have not
     // visited any use of the current operation.
-    if (auto *rewriteListener =
-            dyn_cast_if_present<RewriterBase::Listener>(rewriter.getListener()))
+    if (RewriteListener *rewriteListener = rewriter.getListener())
       rewriteListener->notifyOperationReplaced(op, existing);
     // Replace all uses, but do not remote the operation yet. This does not
     // notify the listener because the original op is not erased.
     rewriter.replaceAllUsesWith(op->getResults(), existing->getResults());
     opsToErase.push_back(op);
   } else {
     // When the region does not have SSA dominance, we need to check if we
     // have visited a use before replacing any use.
     auto wasVisited = [&](OpOperand &operand) {
       return !knownValues.count(operand.getOwner());
     };
-    if (auto *rewriteListener =
-            dyn_cast_if_present<RewriterBase::Listener>(rewriter.getListener()))
+    if (RewriteListener *rewriteListener = rewriter.getListener())
       for (Value v : op->getResults())
         if (all_of(v.getUses(), wasVisited))
           rewriteListener->notifyOperationReplaced(op, existing);
 
     // Replace all uses, but do not remote the operation yet. This does not
     // notify the listener because the original op is not erased.
     rewriter.replaceUsesWithIf(op->getResults(), existing->getResults(),
                                wasVisited);

mlir/lib/Transforms/Utils/FoldUtils.cpp

LogicalResult OperationFolder::tryToFold(Operation *op, bool *inPlaceUpdate) {
   SmallVector<Value, 8> results;
   if (failed(tryToFold(op, results)))
     return failure();
 
   // Check to see if the operation was just updated in place.
   if (results.empty()) {
     if (inPlaceUpdate)
       *inPlaceUpdate = true;
-    if (auto *rewriteListener = dyn_cast_if_present<RewriterBase::Listener>(
-            rewriter.getListener())) {
+    if (RewriteListener *listener = rewriter.getListener()) {
       // Folding API does not notify listeners, so we have to notify manually.
-      rewriteListener->notifyOperationModified(op);
+      listener->notifyOperationModified(op);
     }
     return success();
   }
 
   // Constant folding succeeded. Replace all of the result values and erase the
   // operation.
   notifyRemoval(op);
   rewriter.replaceOp(op, results);

mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp

 //===----------------------------------------------------------------------===//
 // Debugging Infrastructure
 //===----------------------------------------------------------------------===//
 
 #if MLIR_ENABLE_EXPENSIVE_PATTERN_API_CHECKS
 /// A helper struct that stores finger prints of ops in order to detect broken
 /// RewritePatterns. A rewrite pattern is broken if it modifies IR without
 /// using the rewriter API or if it returns an inconsistent return value.
-struct DebugFingerPrints : public RewriterBase::ForwardingListener {
-  DebugFingerPrints(RewriterBase::Listener *driver)
-      : RewriterBase::ForwardingListener(driver) {}
+struct DebugFingerPrints : public ForwardingRewriteListener {
+  DebugFingerPrints(RewriteListener *driver)
+      : RewriterBase::ForwardingRewriteListener(driver) {}
 
   /// Compute finger prints of the given op and its nested ops.
   void computeFingerPrints(Operation *topLevel) {
     this->topLevel = topLevel;
     this->topLevelFingerPrint.emplace(topLevel);
     topLevel->walk([&](Operation *op) { fingerprints.try_emplace(op, op); });
   }
 

 
 /// This is a worklist-driven driver for the PatternMatcher, which repeatedly
 /// applies the locally optimal patterns.
 ///
 /// This abstract class manages the worklist and contains helper methods for
 /// rewriting ops on the worklist. Derived classes specify how ops are added
 /// to the worklist in the beginning.
 class GreedyPatternRewriteDriver : public PatternRewriter,
-                                   public RewriterBase::Listener {
+                                   public RewriteListener {
 protected:
   explicit GreedyPatternRewriteDriver(MLIRContext *ctx,
                                       const FrozenRewritePatternSet &patterns,
                                       const GreedyRewriteConfig &config);
 
   /// Add the given operation to the worklist.
   void addSingleOpToWorklist(Operation *op);
 

mlir/test/lib/Transforms/TestConstantFold.cpp

 //===- TestConstantFold.cpp - Pass to test constant folding ---------------===//
 //
 // 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/Pass/Pass.h"
 #include "mlir/Transforms/FoldUtils.h"
 
 using namespace mlir;
 
 namespace {
 /// Simple constant folding pass.
 struct TestConstantFold : public PassWrapper<TestConstantFold, OperationPass<>>,
-                          public RewriterBase::Listener {
+                          public RewriteListener {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestConstantFold)
 
   StringRef getArgument() const final { return "test-constant-fold"; }
   StringRef getDescription() const final {
     return "Test operation constant folding";
   }
   // All constants in the operation post folding.
   SmallVector<Operation *> existingConstants;