[mlir] Rework the implementation of TypeID

[rriddle]

Summary

This commit restructures how TypeID is implemented to ideally avoid
the current problems related to shared libraries. This is done by changing
the "implicit" fallback path to use the name of the type, instead of using
a static template variable (which breaks shared libraries). The major downside to this
is that it adds some additional initialization costs for the implicit path. Given the
use of type names for uniqueness in the fallback, we also no longer allow types
defined in anonymous namespaces to have an implicit TypeID. To simplify defining
an ID for these classes, a new MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID macro
was added to allow for explicitly defining a TypeID directly on an internal class.

To help identify when types are using the fallback, -debug-only=typeid can be
used to log which types are using implicit ids.

This change generally only requires changes to the test passes, which are all defined
in anonymous namespaces, and thus can't use the fallback any longer.

[jpienaar]

mlir/include/mlir/Support/TypeID.h

249

Could we prefix these by MLIR_ ? Given these are macros exported from a header file that aren't undef'd post use, it would be nicer to "namespace" it in the rework.

[mehdi_amini]

Nice! :)

[rriddle]

mlir/include/mlir/Support/TypeID.h

249

Yep, makes perfect sense.

[stellaraccident]

Thank you so much for this. I'm glad to see the best of both worlds implemented (explicit/homed and name based fallback). I had tried to sketch something not unlike this up in the past but failed to get it into a working form.

I believe this approach will be compatible with the vagaries of windows DLLs too (or can be made compatible where the previous approach could not be).

mlir/include/mlir/Support/TypeID.h

181

Would you mind extending this comment with why this specialization is only valid for fully resolved types?

310–312

A note on why the alignment is important (and why "8")? (Presumably so it can operate as part of a pointer union on all platforms).

[bondhugula]

Nice!

mlir/include/mlir/Support/TypeID.h

168

Nit: it's -> its

[bondhugula]

mlir/include/mlir/Support/TypeID.h

195

It'll be good to have a doc comment here as well. Appreciate the detailed comments everywhere else.

flang/lib/Optimizer/CodeGen/CodeGen.cpp

 private:
   fir::FIRToLLVMPassOptions options;
 };
 
 /// Lower from LLVM IR dialect to proper LLVM-IR and dump the module
 struct LLVMIRLoweringPass
     : public mlir::PassWrapper<LLVMIRLoweringPass,
                                mlir::OperationPass<mlir::ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(LLVMIRLoweringPass)
+
   using Printer = fir::LLVMIRLoweringPrinter;
   LLVMIRLoweringPass(raw_ostream &output, Printer p)
       : output{output}, printer{p} {}
 
   mlir::ModuleOp getModule() { return getOperation(); }
 
   void runOnOperation() override final {
     auto *ctx = getModule().getContext();

flang/lib/Optimizer/Transforms/ArrayValueCopy.cpp

 ///
 /// 2. There is either an array_fetch or array_update of a_j with a different
 /// set of index values. [Possible loop-carried dependence.]
 ///
 /// If none of the array values overlap in storage and the accesses are not
 /// loop-carried, then the arrays are conflict-free and no copies are required.
 class ArrayCopyAnalysis {
 public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ArrayCopyAnalysis)
+
   using ConflictSetT = llvm::SmallPtrSet<mlir::Operation *, 16>;
   using UseSetT = llvm::SmallPtrSet<mlir::OpOperand *, 8>;
   using LoadMapSetsT = llvm::DenseMap<mlir::Operation *, UseSetT>;
   using AmendAccessSetT = llvm::SmallPtrSet<mlir::Operation *, 4>;
 
   ArrayCopyAnalysis(mlir::Operation *op) : operation{op} { construct(op); }
 
   mlir::Operation *getOperation() const { return operation; }

flang/lib/Optimizer/Transforms/MemoryAllocation.cpp

struct MemoryAllocationOptions {
   // Number of elements in array threshold for moving to heap. In environments
   // with limited stack size, moving large arrays to the heap can avoid running
   // out of stack space.
   std::size_t maxStackArraySize = unlimitedArraySize;
 };
 
 class ReturnAnalysis {
 public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ReturnAnalysis)
+
   ReturnAnalysis(mlir::Operation *op) {
     if (auto func = mlir::dyn_cast<mlir::FuncOp>(op))
       for (mlir::Block &block : func)
         for (mlir::Operation &i : block)
           if (mlir::isa<mlir::func::ReturnOp>(i)) {
             returnMap[op].push_back(&i);
             break;
           }

mlir/examples/toy/Ch4/mlir/ShapeInferencePass.cpp

 ///   2) Iterate on the worklist:
 ///     a) find an operation to process: the next ready operation in the
 ///        worklist has all of its arguments non-generic,
 ///     b) if no operation is found, break out of the loop,
 ///     c) remove the operation from the worklist,
 ///     d) infer the shape of its output from the argument types.
 ///   3) If the worklist is empty, the algorithm succeeded.
 ///
-class ShapeInferencePass
+struct ShapeInferencePass
     : public mlir::PassWrapper<ShapeInferencePass, OperationPass<toy::FuncOp>> {
-public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ShapeInferencePass)
+
   void runOnOperation() override {
     auto f = getOperation();
 
     // Populate the worklist with the operations that need shape inference:
     // these are operations that return a dynamic shape.
     llvm::SmallPtrSet<mlir::Operation *, 16> opWorklist;
     f.walk([&](mlir::Operation *op) {
       if (returnsDynamicShape(op))

mlir/examples/toy/Ch5/mlir/LowerToAffineLoops.cpp

 //===----------------------------------------------------------------------===//
 
 /// This is a partial lowering to affine loops of the toy operations that are
 /// computationally intensive (like matmul for example...) while keeping the
 /// rest of the code in the Toy dialect.
 namespace {
 struct ToyToAffineLoweringPass
     : public PassWrapper<ToyToAffineLoweringPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ToyToAffineLoweringPass)
+
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, func::FuncDialect, memref::MemRefDialect>();
   }
   void runOnOperation() final;
 };
 } // namespace
 
 void ToyToAffineLoweringPass::runOnOperation() {

mlir/examples/toy/Ch5/mlir/ShapeInferencePass.cpp

 ///   2) Iterate on the worklist:
 ///     a) find an operation to process: the next ready operation in the
 ///        worklist has all of its arguments non-generic,
 ///     b) if no operation is found, break out of the loop,
 ///     c) remove the operation from the worklist,
 ///     d) infer the shape of its output from the argument types.
 ///   3) If the worklist is empty, the algorithm succeeded.
 ///
-class ShapeInferencePass
+struct ShapeInferencePass
     : public mlir::PassWrapper<ShapeInferencePass, OperationPass<toy::FuncOp>> {
-public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ShapeInferencePass)
+
   void runOnOperation() override {
     auto f = getOperation();
 
     // Populate the worklist with the operations that need shape inference:
     // these are operations that return a dynamic shape.
     llvm::SmallPtrSet<mlir::Operation *, 16> opWorklist;
     f.walk([&](mlir::Operation *op) {
       if (returnsDynamicShape(op))

mlir/examples/toy/Ch6/mlir/LowerToAffineLoops.cpp

 //===----------------------------------------------------------------------===//
 
 /// This is a partial lowering to affine loops of the toy operations that are
 /// computationally intensive (like matmul for example...) while keeping the
 /// rest of the code in the Toy dialect.
 namespace {
 struct ToyToAffineLoweringPass
     : public PassWrapper<ToyToAffineLoweringPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ToyToAffineLoweringPass)
+
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, func::FuncDialect, memref::MemRefDialect>();
   }
   void runOnOperation() final;
 };
 } // namespace
 
 void ToyToAffineLoweringPass::runOnOperation() {

mlir/examples/toy/Ch6/mlir/LowerToLLVM.cpp

 
 //===----------------------------------------------------------------------===//
 // ToyToLLVMLoweringPass
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct ToyToLLVMLoweringPass
     : public PassWrapper<ToyToLLVMLoweringPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ToyToLLVMLoweringPass)
+
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<LLVM::LLVMDialect, scf::SCFDialect>();
   }
   void runOnOperation() final;
 };
 } // namespace
 
 void ToyToLLVMLoweringPass::runOnOperation() {

mlir/examples/toy/Ch6/mlir/ShapeInferencePass.cpp

 ///   2) Iterate on the worklist:
 ///     a) find an operation to process: the next ready operation in the
 ///        worklist has all of its arguments non-generic,
 ///     b) if no operation is found, break out of the loop,
 ///     c) remove the operation from the worklist,
 ///     d) infer the shape of its output from the argument types.
 ///   3) If the worklist is empty, the algorithm succeeded.
 ///
-class ShapeInferencePass
+struct ShapeInferencePass
     : public mlir::PassWrapper<ShapeInferencePass, OperationPass<toy::FuncOp>> {
-public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ShapeInferencePass)
+
   void runOnOperation() override {
     auto f = getOperation();
 
     // Populate the worklist with the operations that need shape inference:
     // these are operations that return a dynamic shape.
     llvm::SmallPtrSet<mlir::Operation *, 16> opWorklist;
     f.walk([&](mlir::Operation *op) {
       if (returnsDynamicShape(op))

mlir/examples/toy/Ch7/mlir/LowerToAffineLoops.cpp

 //===----------------------------------------------------------------------===//
 
 /// This is a partial lowering to affine loops of the toy operations that are
 /// computationally intensive (like matmul for example...) while keeping the
 /// rest of the code in the Toy dialect.
 namespace {
 struct ToyToAffineLoweringPass
     : public PassWrapper<ToyToAffineLoweringPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ToyToAffineLoweringPass)
+
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, func::FuncDialect, memref::MemRefDialect>();
   }
   void runOnOperation() final;
 };
 } // namespace
 
 void ToyToAffineLoweringPass::runOnOperation() {

mlir/examples/toy/Ch7/mlir/LowerToLLVM.cpp

 
 //===----------------------------------------------------------------------===//
 // ToyToLLVMLoweringPass
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct ToyToLLVMLoweringPass
     : public PassWrapper<ToyToLLVMLoweringPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ToyToLLVMLoweringPass)
+
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<LLVM::LLVMDialect, scf::SCFDialect>();
   }
   void runOnOperation() final;
 };
 } // namespace
 
 void ToyToLLVMLoweringPass::runOnOperation() {

mlir/examples/toy/Ch7/mlir/ShapeInferencePass.cpp

 ///   2) Iterate on the worklist:
 ///     a) find an operation to process: the next ready operation in the
 ///        worklist has all of its arguments non-generic,
 ///     b) if no operation is found, break out of the loop,
 ///     c) remove the operation from the worklist,
 ///     d) infer the shape of its output from the argument types.
 ///   3) If the worklist is empty, the algorithm succeeded.
 ///
-class ShapeInferencePass
+struct ShapeInferencePass
     : public mlir::PassWrapper<ShapeInferencePass, OperationPass<toy::FuncOp>> {
-public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ShapeInferencePass)
+
   void runOnOperation() override {
     auto f = getOperation();
 
     // Populate the worklist with the operations that need shape inference:
     // these are operations that return a dynamic shape.
     llvm::SmallPtrSet<mlir::Operation *, 16> opWorklist;
     f.walk([&](mlir::Operation *op) {
       if (returnsDynamicShape(op))

mlir/include/mlir/Conversion/SCFToGPU/SCFToGPUPass.h

 //===- SCFToGPUPass.h - Pass converting loops to GPU kernels ----*- 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_CONVERSION_SCFTOGPU_SCFTOGPUPASS_H_
 #define MLIR_CONVERSION_SCFTOGPU_SCFTOGPUPASS_H_
 
+#include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/Support/LLVM.h"
 
 #include <memory>
 
 namespace mlir {
-class FunctionOpInterface;
 template <typename T>
 class InterfacePass;
 class Pass;
 
 /// Create a pass that converts loop nests into GPU kernels.  It considers
 /// top-level affine.for operations as roots of loop nests and converts them to
 /// the gpu.launch operations if possible.
 ///

mlir/include/mlir/Pass/AnalysisManager.h

 //===----------------------------------------------------------------------===//
 // Analysis Preservation and Concept Modeling
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 /// A utility class to represent the analyses that are known to be preserved.
 class PreservedAnalyses {
   /// A type used to represent all potential analyses.
-  struct AllAnalysesType;
+  struct AllAnalysesType {};
 
 public:
   /// Mark all analyses as preserved.
   void preserveAll() { preservedIDs.insert(TypeID::get<AllAnalysesType>()); }
 
   /// Returns true if all analyses were marked preserved.
   bool isAll() const {
     return preservedIDs.count(TypeID::get<AllAnalysesType>());

mlir/include/mlir/Support/TypeID.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_SUPPORT_TYPEID_H
 #define MLIR_SUPPORT_TYPEID_H
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
+#include "llvm/Support/TypeName.h"
 
 namespace mlir {
-
-namespace detail {
-struct TypeIDExported;
-} // namespace detail
+//===----------------------------------------------------------------------===//
+// TypeID
+//===----------------------------------------------------------------------===//
 
 /// This class provides an efficient unique identifier for a specific C++ type.
 /// This allows for a C++ type to be compared, hashed, and stored in an opaque
 /// context. This class is similar in some ways to std::type_index, but can be
 /// used for any type. For example, this class could be used to implement LLVM
 /// style isa/dyn_cast functionality for a type hierarchy:
 ///
 ///  struct Base {

 ///    }
 ///  };
 ///
 ///  void foo(Base *base) {
 ///    if (DerivedA *a = llvm::dyn_cast<DerivedA>(base))
 ///       ...
 ///  }
 ///
+/// C++ RTTI is a notoriously difficult topic; given the nature of shared
+/// libraries many different approaches fundamentally break down in either the
+/// area of support (i.e. only certain types of classes are supported), or in
+/// terms of performance (e.g. by using string comparison). This class intends
+/// to strike a balance between performance and the setup required to enable its
+/// use.
+///
+/// Assume we are adding support for some class Foo, below are the set of ways
+/// in which a given c++ type may be supported:
+///
+///  * Explicitly via `MLIR_DECLARE_EXPLICIT_TYPE_ID` and
+///    `MLIR_DEFINE_EXPLICIT_TYPE_ID`
+///
+///    - This method explicitly defines the type ID for a given type using the
+///      given macros. These should be placed at the top-level of the file (i.e.
+///      not within any namespace or class). This is the most effective and
+///      efficient method, but requires explicit annotations for each type.
+///
+///      Example:
+///
+///        // Foo.h
+///        MLIR_DECLARE_EXPLICIT_TYPE_ID(Foo);
+///
+///        // Foo.cpp
+///        MLIR_DEFINE_EXPLICIT_TYPE_ID(Foo);
+///
+///  * Explicitly via `MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID`
+///   - This method explicitly defines the type ID for a given type by
+///     annotating the class directly. This has similar effectiveness and
+///     efficiency to the above method, but should only be used on internal
+///     classes; i.e. those with definitions constrained to a specific library
+///     (generally classes in anonymous namespaces).
+///
+///     Example:
+///
+///       namespace {
+///       class Foo {
+///       public:
+///         MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(Foo)
+///       };
+///       } // namespace
+///
+///  * Implicitly via a fallback using the type name
+///   - This method implicitly defines a type ID for a given type by using the
+///     type name. This method requires nothing explicitly from the user, but
+///     pays additional access and initialization cost. Given that this method
+///     uses the name of the type, it may not be used for types defined in
+///     anonymous namespaces (which is asserted when it can be detected). String
+///     names do not provide any guarantees on uniqueness in these contexts.
+///
 class TypeID {
   /// This class represents the storage of a type info object.
   /// Note: We specify an explicit alignment here to allow use with
   /// PointerIntPair and other utilities/data structures that require a known
   /// pointer alignment.
   struct alignas(8) Storage {};
 
 public:
public:
   friend ::llvm::hash_code hash_value(TypeID id);
 
 private:
   TypeID(const Storage *storage) : storage(storage) {}
 
   /// The storage of this type info object.
   const Storage *storage;
 
-  // See TypeIDExported below for an explanation of the trampoline behavior.
-  friend struct detail::TypeIDExported;
-
   friend class TypeIDAllocator;
 };
 
 /// Enable hashing TypeID.
 inline ::llvm::hash_code hash_value(TypeID id) {
   return DenseMapInfo<const TypeID::Storage *>::getHashValue(id.storage);
 }
 
+//===----------------------------------------------------------------------===//
+// TypeIDResolver
+//===----------------------------------------------------------------------===//
+
 namespace detail {
+/// This class provides a fallback for resolving TypeIDs. It uses the string
+/// name of the type to perform the resolution, and as such does not allow the
+/// use of classes defined in "anonymous" contexts.
+class FallbackTypeIDResolver {
+protected:
+  /// Register an implicit type ID for the given type name.
+  static TypeID registerImplicitTypeID(StringRef name);
+};
 
-/// The static local instance of each get method must be emitted with
-/// "default" (public) visibility across all shared libraries, regardless of
-/// whether they are compiled with hidden visibility or not. The only reliable
-/// way to make this happen is to set the visibility attribute at the
-/// containing namespace/struct scope. We don't do this on the TypeID (internal
-/// API) class in order to reduce the scope of what gets exported with
-/// public visibility. Instead, the get() methods on TypeID trampoline
-/// through those on this detail class with specific visibility controls
-/// applied, making visibility declarations on the internal TypeID class not
-/// required (all visibility relevant pieces are here).
-/// TODO: This currently won't work when using DLLs as it requires properly
-/// attaching dllimport and dllexport. Fix this when that information is
-/// available within LLVM.
-struct LLVM_EXTERNAL_VISIBILITY TypeIDExported {
-  template <typename T>
-  static TypeID get() {
-    static TypeID::Storage instance;
-    return TypeID(&instance);
-  }
-  template <template <typename> class Trait>
-  static TypeID get() {
-    static TypeID::Storage instance;
-    return TypeID(&instance);
+/// This class provides a resolver for getting the ID for a given class T. This
+/// allows for the derived type to specialize its resolution behavior. The
+/// default implementation uses the string name of the type to resolve the ID.
+/// This provides a strong definition, but at the cost of performance (we need
+/// to do an initial lookup) and is not usable by classes defined in anonymous
+/// contexts.
+///
+/// TODO: The use of the type name is only necessary when building in the
+/// presence of shared libraries. We could add a build flag that guarantees
+/// "static"-like environments and switch this to a more optimal implementation
+/// when that is enabled.
+template <typename T, typename Enable = void>
+class TypeIDResolver : public FallbackTypeIDResolver {
+public:
+  /// Trait to check if `U` is fully resolved. We use this to verify that `T` is
+  /// fully resolved when trying to resolve a TypeID. We don't technically need
+  /// to have the full definition of `T` for the fallback, but it does help
+  /// prevent situations where a forward declared type uses this fallback even
+  /// though there is a strong definition for the TypeID in the location where
+  /// `T` is defined.
+  template <typename U>
+  using is_fully_resolved_trait = decltype(sizeof(U));
+  template <typename U>
+  using is_fully_resolved = llvm::is_detected<is_fully_resolved_trait, U>;
+
+  static TypeID resolveTypeID() {
+    static_assert(is_fully_resolved<T>::value,
+                  "TypeID::get<> requires the complete definition of `T`");
+    static TypeID id = registerImplicitTypeID(llvm::getTypeName<T>());
+    return id;
   }
 };
 
+/// This class provides utilities for resolving the TypeID of a class that
+/// provides a `static TypeID resolveTypeID()` method. This allows for
+/// simplifying situations when the class can resolve the ID itself. This
+/// functionality is separated from the corresponding `TypeIDResolver`
+/// specialization below to enable referencing it more easily in different
+/// contexts.
+struct InlineTypeIDResolver {
+  /// Trait to check if `T` provides a static `resolveTypeID` method.
+  template <typename T>
+  using has_resolve_typeid_trait = decltype(T::resolveTypeID());
+  template <typename T>
+  using has_resolve_typeid = llvm::is_detected<has_resolve_typeid_trait, T>;
+
+  template <typename T>
+  static TypeID resolveTypeID() {
+    return T::resolveTypeID();
+  }
+};
+/// This class provides a resolver for getting the ID for a given class T, when
+/// the class provides a `static TypeID resolveTypeID()` method. This allows for
+/// simplifying situations when the class can resolve the ID itself.
+template <typename T>
+class TypeIDResolver<
+    T, std::enable_if_t<InlineTypeIDResolver::has_resolve_typeid<T>::value>> {
+public:
+  static TypeID resolveTypeID() {
+    return InlineTypeIDResolver::resolveTypeID<T>();
+  }
+};
 } // namespace detail
 
 template <typename T>
 TypeID TypeID::get() {
-  return detail::TypeIDExported::get<T>();
+  return detail::TypeIDResolver<T>::resolveTypeID();
 }
 template <template <typename> class Trait>
 TypeID TypeID::get() {
-  return detail::TypeIDExported::get<Trait>();
+  // An empty class used to simplify the use of Trait types.
+  struct Empty {};
+  return TypeID::get<Trait<Empty>>();
 }
 
+// Declare/define an explicit specialization for TypeID: this forces the
+// compiler to emit a strong definition for a class and controls which
+// translation unit and shared object will actually have it.
+// This can be useful to turn to a link-time failure what would be in other
+// circumstances a hard-to-catch runtime bug when a TypeID is hidden in two
+// different shared libraries and instances of the same class only gets the same
+// TypeID inside a given DSO.
+#define MLIR_DECLARE_EXPLICIT_TYPE_ID(CLASS_NAME)                              \
+  namespace mlir {                                                             \
+  namespace detail {                                                           \
+  template <>                                                                  \
+  class TypeIDResolver<CLASS_NAME> {                                           \
+  public:                                                                      \
+    static TypeID resolveTypeID() { return id; }                               \
+                                                                               \
+  private:                                                                     \
+    static SelfOwningTypeID id;                                                \
+  };                                                                           \
+  } /* namespace detail */                                                     \
+  } /* namespace mlir */
+
+#define MLIR_DEFINE_EXPLICIT_TYPE_ID(CLASS_NAME)                               \
+  namespace mlir {                                                             \
+  namespace detail {                                                           \
+  SelfOwningTypeID TypeIDResolver<CLASS_NAME>::id = {};                        \
+  } /* namespace detail */                                                     \
+  } /* namespace mlir */
+
+// Declare/define an explicit, **internal**, specialization of TypeID for the
+// given class. This is useful for providing an explicit specialization of
+// TypeID for a class that is known to be internal to a specific library. It
+// should be placed within a public section of the declaration of the class.
+#define MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(CLASS_NAME)               \
+  static ::mlir::TypeID resolveTypeID() {                                      \
+    static ::mlir::SelfOwningTypeID id;                                        \
+    return id;                                                                 \
+  }                                                                            \
+  static_assert(                                                               \
+      ::mlir::detail::InlineTypeIDResolver::has_resolve_typeid<                \
+          CLASS_NAME>::value,                                                  \
+      "`MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID` must be placed in a "    \
+      "public section of `" #CLASS_NAME "`");
+
+//===----------------------------------------------------------------------===//
+// TypeIDAllocator
+//===----------------------------------------------------------------------===//
+
 /// This class provides a way to define new TypeIDs at runtime.
 /// When the allocator is destructed, all allocated TypeIDs become invalid and
 /// therefore should not be used.
 class TypeIDAllocator {
 public:
   /// Allocate a new TypeID, that is ensured to be unique for the lifetime
   /// of the TypeIDAllocator.
   TypeID allocate() { return TypeID(ids.Allocate()); }
 
 private:
   /// The TypeIDs allocated are the addresses of the different storages.
   /// Keeping those in memory ensure uniqueness of the TypeIDs.
   llvm::SpecificBumpPtrAllocator<TypeID::Storage> ids;
 };
 
+//===----------------------------------------------------------------------===//
+// SelfOwningTypeID
+//===----------------------------------------------------------------------===//
+
 /// Defines a TypeID for each instance of this class by using a pointer to the
 /// instance. Thus, the copy and move constructor are deleted.
-class SelfOwningTypeID {
+/// Note: We align by 8 to match the alignment of TypeID::Storage, as we treat
+/// an instance of this class similarly to TypeID::Storage.
+class alignas(8) SelfOwningTypeID {
 public:
   SelfOwningTypeID() = default;
   SelfOwningTypeID(const SelfOwningTypeID &) = delete;
   SelfOwningTypeID &operator=(const SelfOwningTypeID &) = delete;
   SelfOwningTypeID(SelfOwningTypeID &&) = delete;
   SelfOwningTypeID &operator=(SelfOwningTypeID &&) = delete;
 
+  /// Implicitly converts to the owned TypeID.
+  operator TypeID() const { return getTypeID(); }
+
+  /// Return the TypeID owned by this object.
   TypeID getTypeID() const { return TypeID::getFromOpaquePointer(this); }
 };
 
 } // namespace mlir
 
-// Declare/define an explicit specialization for TypeID: this forces the
-// compiler to emit a strong definition for a class and controls which
-// translation unit and shared object will actually have it.
-// This can be useful to turn to a link-time failure what would be in other
-// circumstances a hard-to-catch runtime bug when a TypeID is hidden in two
-// different shared libraries and instances of the same class only gets the same
-// TypeID inside a given DSO.
-#define DECLARE_EXPLICIT_TYPE_ID(CLASS_NAME)                                   \
-  namespace mlir {                                                             \
-  namespace detail {                                                           \
-  template <>                                                                  \
-  LLVM_EXTERNAL_VISIBILITY TypeID TypeIDExported::get<CLASS_NAME>();           \
-  }                                                                            \
-  }
+//===----------------------------------------------------------------------===//
+// Builtin TypeIDs
+//===----------------------------------------------------------------------===//
 
-#define DEFINE_EXPLICIT_TYPE_ID(CLASS_NAME)                                    \
-  namespace mlir {                                                             \
-  namespace detail {                                                           \
-  template <>                                                                  \
-  LLVM_EXTERNAL_VISIBILITY TypeID TypeIDExported::get<CLASS_NAME>() {          \
-    static TypeID::Storage instance;                                           \
-    return TypeID(&instance);                                                  \
-  }                                                                            \
-  }                                                                            \
-  }
+/// Explicitly register a set of "builtin" types.
+MLIR_DECLARE_EXPLICIT_TYPE_ID(void)
 
 namespace llvm {
 template <> struct DenseMapInfo<mlir::TypeID> {
   static inline mlir::TypeID getEmptyKey() {
     void *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::TypeID::getFromOpaquePointer(pointer);
   }
   static inline mlir::TypeID getTombstoneKey() {

mlir/include/mlir/Tools/PDLL/AST/Types.h

public:
   /// Return an instance of the Value type.
   static ValueType get(Context &context);
 };
 
 } // namespace ast
 } // namespace pdll
 } // namespace mlir
 
+MLIR_DECLARE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::AttributeTypeStorage)
+MLIR_DECLARE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::ConstraintTypeStorage)
+MLIR_DECLARE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::OperationTypeStorage)
+MLIR_DECLARE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::RangeTypeStorage)
+MLIR_DECLARE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::RewriteTypeStorage)
+MLIR_DECLARE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::TupleTypeStorage)
+MLIR_DECLARE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::TypeTypeStorage)
+MLIR_DECLARE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::ValueTypeStorage)
+
 namespace llvm {
 template <> struct DenseMapInfo<mlir::pdll::ast::Type> {
   static mlir::pdll::ast::Type getEmptyKey() {
     void *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::pdll::ast::Type(
         static_cast<mlir::pdll::ast::Type::Storage *>(pointer));
   }
   static mlir::pdll::ast::Type getTombstoneKey() {

mlir/lib/Conversion/PassDetail.h

 //===- PassDetail.h - Conversion Pass class details -------------*- 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 CONVERSION_PASSDETAIL_H_
 #define CONVERSION_PASSDETAIL_H_
 
 #include "mlir/Pass/Pass.h"
 
 #include "mlir/Conversion/GPUToROCDL/Runtimes.h"
+#include "mlir/IR/FunctionInterfaces.h"
 
 namespace mlir {
 class AffineDialect;
-class FunctionOpInterface;
 
 // Forward declaration from Dialect.h
 template <typename ConcreteDialect>
 void registerDialect(DialectRegistry &registry);
 
 namespace acc {
 class OpenACCDialect;
 } // namespace acc

mlir/lib/Dialect/GPU/Transforms/SerializeToHsaco.cpp

 #include <mutex>
 
 using namespace mlir;
 
 namespace {
 class SerializeToHsacoPass
     : public PassWrapper<SerializeToHsacoPass, gpu::SerializeToBlobPass> {
 public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SerializeToHsacoPass)
+
   SerializeToHsacoPass(StringRef triple, StringRef arch, StringRef features,
                        int optLevel);
   SerializeToHsacoPass(const SerializeToHsacoPass &other);
   StringRef getArgument() const override { return "gpu-to-hsaco"; }
   StringRef getDescription() const override {
     return "Lower GPU kernel function to HSACO binary annotations";
   }
 

mlir/lib/Dialect/SPIRV/Transforms/UnifyAliasedResourcePass.cpp

 /// Resources are expected to be spv.GlobalVarible that has a descriptor set and
 /// binding number. Such resources are of the type `!spv.ptr<!spv.struct<...>>`
 /// per Vulkan requirements.
 ///
 /// Right now, we only support the case that there is a single runtime array
 /// inside the struct.
 class ResourceAliasAnalysis {
 public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ResourceAliasAnalysis)
+
   explicit ResourceAliasAnalysis(Operation *);
 
   /// Returns true if the given `op` can be rewritten to use a canonical
   /// resource.
   bool shouldUnify(Operation *op) const;
 
   /// Returns all descriptors and their corresponding aliased resources.
   const AliasedResourceMap &getResourceMap() const { return resourceMap; }

mlir/lib/Parser/Parser.cpp

public:
   /// entries in the tuple are the name and result number of a reference.  The
   /// third is the location of the reference, which is used in case this ends
   /// up being a use of an undefined value.
   struct SSAUseInfo {
     StringRef name;  // Value name, e.g. %42 or %abc
     unsigned number; // Number, specified with #12
     SMLoc loc;       // Location of first definition or use.
   };
+  struct DeferredLocInfo {
+    SMLoc loc;
+    StringRef identifier;
+  };
 
   /// Push a new SSA name scope to the parser.
   void pushSSANameScope(bool isIsolated);
 
   /// Pop the last SSA name scope from the parser.
   ParseResult popSSANameScope();
 
   /// Register a definition of a value with the symbol table.
private:
 
   /// These are all of the placeholders we've made along with the location of
   /// their first reference, to allow checking for use of undefined values.
   DenseMap<Value, SMLoc> forwardRefPlaceholders;
 
   /// Deffered locations: when parsing `loc(#loc42)` we add an entry to this
   /// map. After parsing the definition `#loc42 = ...` we'll patch back users
   /// of this location.
-  struct DeferredLocInfo {
-    SMLoc loc;
-    StringRef identifier;
-  };
   std::vector<DeferredLocInfo> deferredLocsReferences;
 
   /// The builder used when creating parsed operation instances.
   OpBuilder opBuilder;
 
   /// The top level operation that holds all of the parsed operations.
   Operation *topLevelOp;
 };
 } // namespace
 
+MLIR_DECLARE_EXPLICIT_TYPE_ID(OperationParser::DeferredLocInfo *)
+MLIR_DEFINE_EXPLICIT_TYPE_ID(OperationParser::DeferredLocInfo *)
+
 OperationParser::OperationParser(ParserState &state, ModuleOp topLevelOp)
     : Parser(state), opBuilder(topLevelOp.getRegion()), topLevelOp(topLevelOp) {
   // The top level operation starts a new name scope.
   pushSSANameScope(/*isIsolated=*/true);
 
   // If we are populating the parser state, prepare it for parsing.
   if (state.asmState)
     state.asmState->initialize(topLevelOp);

mlir/lib/Support/CMakeLists.txt

 set(LLVM_OPTIONAL_SOURCES
   DebugCounter.cpp
   FileUtilities.cpp
   IndentedOstream.cpp
   InterfaceSupport.cpp
   StorageUniquer.cpp
   Timing.cpp
   ToolUtilities.cpp
+  TypeID.cpp
 )
 
 add_mlir_library(MLIRSupport
   DebugCounter.cpp
   FileUtilities.cpp
   IndentedOstream.cpp
   InterfaceSupport.cpp
   StorageUniquer.cpp
   Timing.cpp
   ToolUtilities.cpp
+  TypeID.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Support
 
   LINK_LIBS PUBLIC
   ${LLVM_PTHREAD_LIB})
 
 # This doesn't use add_mlir_library as it is used in mlir-tblgen and else

mlir/lib/Support/TypeID.cpp

+//===- TypeID.cpp - MLIR TypeID -------------------------------------------===//
+//
+// 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/Support/TypeID.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/RWMutex.h"
+
+#include "llvm/Support/Signals.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace mlir;
+
+#define DEBUG_TYPE "typeid"
+
+//===----------------------------------------------------------------------===//
+// TypeID Registry
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct ImplicitTypeIDRegistry {
+  /// Lookup or insert a TypeID for the given type name.
+  TypeID lookupOrInsert(StringRef typeName) {
+    LLVM_DEBUG(llvm::dbgs() << "ImplicitTypeIDRegistry::lookupOrInsert("
+                            << typeName << ")\n");
+
+    // Perform a heuristic check to see if this type is in an anonymous
+    // namespace. String equality is not valid for anonymous types, so we try to
+    // abort whenever we see them.
+#ifndef NDEBUG
+#if defined(_MSC_VER)
+    if (typeName.contains("anonymous-namespace")) {
+#else
+    if (typeName.contains("anonymous namespace")) {
+#endif
+      std::string errorStr;
+      {
+        llvm::raw_string_ostream errorOS(errorStr);
+        errorOS << "TypeID::get<" << typeName
+                << ">(): Using TypeID on a class with an anonymous "
+                   "namespace requires an explicit TypeID definition. The "
+                   "implicit fallback uses string name, which does not "
+                   "guarantee uniqueness in anonymous contexts. Define an "
+                   "explicit TypeID instantiation for this type using "
+                   "`MLIR_DECLARE_EXPLICIT_TYPE_ID`/"
+                   "`MLIR_DEFINE_EXPLICIT_TYPE_ID` or "
+                   "`DEFINE_EXPLICIT_PRIVATE_INLINE_TYPE_ID`.\n";
+      }
+      llvm::report_fatal_error(errorStr);
+    }
+#endif
+
+    { // Try a read-only lookup first.
+      llvm::sys::SmartScopedReader<true> guard(mutex);
+      auto it = typeNameToID.find(typeName);
+      if (it != typeNameToID.end())
+        return it->second;
+    }
+    llvm::sys::SmartScopedWriter<true> guard(mutex);
+    auto it = typeNameToID.try_emplace(typeName, TypeID());
+    if (it.second)
+      it.first->second = typeIDAllocator.allocate();
+    return it.first->second;
+  }
+
+  /// A mutex that guards access to the registry.
+  llvm::sys::SmartRWMutex<true> mutex;
+
+  /// An allocator used for TypeID objects.
+  TypeIDAllocator typeIDAllocator;
+
+  /// A map type name to TypeID.
+  DenseMap<StringRef, TypeID> typeNameToID;
+};
+} // end namespace
+
+TypeID detail::FallbackTypeIDResolver::registerImplicitTypeID(StringRef name) {
+  static ImplicitTypeIDRegistry registry;
+  return registry.lookupOrInsert(name);
+}
+
+//===----------------------------------------------------------------------===//
+// Builtin TypeIDs
+//===----------------------------------------------------------------------===//
+
+MLIR_DEFINE_EXPLICIT_TYPE_ID(void)

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

 using namespace mlir;
 
 namespace {
 /// ModuleTranslation stack frame for OpenMP operations. This keeps track of the
 /// insertion points for allocas.
 class OpenMPAllocaStackFrame
     : public LLVM::ModuleTranslation::StackFrameBase<OpenMPAllocaStackFrame> {
 public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OpenMPAllocaStackFrame)
+
   explicit OpenMPAllocaStackFrame(llvm::OpenMPIRBuilder::InsertPointTy allocaIP)
       : allocaInsertPoint(allocaIP) {}
   llvm::OpenMPIRBuilder::InsertPointTy allocaInsertPoint;
 };
 
 /// ModuleTranslation stack frame containing the partial mapping between MLIR
 /// values and their LLVM IR equivalents.
 class OpenMPVarMappingStackFrame
     : public LLVM::ModuleTranslation::StackFrameBase<
           OpenMPVarMappingStackFrame> {
 public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OpenMPVarMappingStackFrame)
+
   explicit OpenMPVarMappingStackFrame(
       const DenseMap<Value, llvm::Value *> &mapping)
       : mapping(mapping) {}
 
   DenseMap<Value, llvm::Value *> mapping;
 };
 } // namespace
 

mlir/lib/Tools/PDLL/AST/Types.cpp

 //===- Types.cpp ----------------------------------------------------------===//
 //
 // 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/Tools/PDLL/AST/Types.h"
 #include "TypeDetail.h"
 #include "mlir/Tools/PDLL/AST/Context.h"
 
 using namespace mlir;
 using namespace mlir::pdll::ast;
 
+MLIR_DEFINE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::AttributeTypeStorage)
+MLIR_DEFINE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::ConstraintTypeStorage)
+MLIR_DEFINE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::OperationTypeStorage)
+MLIR_DEFINE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::RangeTypeStorage)
+MLIR_DEFINE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::RewriteTypeStorage)
+MLIR_DEFINE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::TupleTypeStorage)
+MLIR_DEFINE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::TypeTypeStorage)
+MLIR_DEFINE_EXPLICIT_TYPE_ID(mlir::pdll::ast::detail::ValueTypeStorage)
+
 //===----------------------------------------------------------------------===//
 // Type
 //===----------------------------------------------------------------------===//
 
 TypeID Type::getTypeID() const { return impl->typeID; }
 
 Type Type::refineWith(Type other) const {
   if (*this == other)

mlir/test/CAPI/ir.c

int testTypeID(MlirContext ctx) {
   if (!mlirTypeIDEqual(i32ID, ui32ID) ||
       mlirTypeIDHashValue(i32ID) != mlirTypeIDHashValue(ui32ID)) {
     fprintf(
         stderr,
         "ERROR: Expected different integer types to have the same type id\n");
     return 2;
   }
 
-  if (mlirTypeIDEqual(i32ID, f32ID) ||
-      mlirTypeIDHashValue(i32ID) == mlirTypeIDHashValue(f32ID)) {
+  if (mlirTypeIDEqual(i32ID, f32ID)) {
     fprintf(stderr,
             "ERROR: Expected integer type id to not equal float type id\n");
     return 3;
   }
 
-  if (mlirTypeIDEqual(i32ID, i32AttrID) ||
-      mlirTypeIDHashValue(i32ID) == mlirTypeIDHashValue(i32AttrID)) {
+  if (mlirTypeIDEqual(i32ID, i32AttrID)) {
     fprintf(stderr, "ERROR: Expected integer type id to not equal integer "
                     "attribute type id\n");
     return 4;
   }
 
   MlirLocation loc = mlirLocationUnknownGet(ctx);
   MlirType indexType = mlirIndexTypeGet(ctx);
   MlirStringRef valueStringRef = mlirStringRefCreateFromCString("value");

mlir/test/lib/Analysis/TestAliasAnalysis.cpp

 
 //===----------------------------------------------------------------------===//
 // Testing AliasResult
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct TestAliasAnalysisPass
     : public PassWrapper<TestAliasAnalysisPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestAliasAnalysisPass)
+
   StringRef getArgument() const final { return "test-alias-analysis"; }
   StringRef getDescription() const final {
     return "Test alias analysis results.";
   }
   void runOnOperation() override {
     llvm::errs() << "Testing : " << getOperation()->getAttr("sym_name") << "\n";
 
     // Collect all of the values to check for aliasing behavior.

 
 //===----------------------------------------------------------------------===//
 // Testing ModRefResult
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct TestAliasAnalysisModRefPass
     : public PassWrapper<TestAliasAnalysisModRefPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestAliasAnalysisModRefPass)
+
   StringRef getArgument() const final { return "test-alias-analysis-modref"; }
   StringRef getDescription() const final {
     return "Test alias analysis ModRef results.";
   }
   void runOnOperation() override {
     llvm::errs() << "Testing : " << getOperation()->getAttr("sym_name") << "\n";
 
     // Collect all of the values to check for aliasing behavior.

mlir/test/lib/Analysis/TestCallGraph.cpp

 #include "mlir/Analysis/CallGraph.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 struct TestCallGraphPass
     : public PassWrapper<TestCallGraphPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestCallGraphPass)
+
   StringRef getArgument() const final { return "test-print-callgraph"; }
   StringRef getDescription() const final {
     return "Print the contents of a constructed callgraph.";
   }
   void runOnOperation() override {
     llvm::errs() << "Testing : " << getOperation()->getAttr("test.name")
                  << "\n";
     getAnalysis<CallGraph>().print(llvm::errs());

mlir/test/lib/Analysis/TestLiveness.cpp

 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 
 struct TestLivenessPass
     : public PassWrapper<TestLivenessPass, InterfacePass<SymbolOpInterface>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLivenessPass)
+
   StringRef getArgument() const final { return "test-print-liveness"; }
   StringRef getDescription() const final {
     return "Print the contents of a constructed liveness information.";
   }
   void runOnOperation() override {
     llvm::errs() << "Testing : " << getOperation().getName() << "\n";
     getAnalysis<Liveness>().print(llvm::errs());
   }

mlir/test/lib/Analysis/TestMatchReduction.cpp

void printReductionResult(Operation *redRegionOp, unsigned numOutput,
 
   redRegionOp->emitRemark("Reduction NOT found in output #")
       << numOutput << "!";
 }
 
 struct TestMatchReductionPass
     : public PassWrapper<TestMatchReductionPass,
                          InterfacePass<FunctionOpInterface>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestMatchReductionPass)
+
   StringRef getArgument() const final { return "test-match-reduction"; }
   StringRef getDescription() const final {
     return "Test the match reduction utility.";
   }
 
   void runOnOperation() override {
     FunctionOpInterface func = getOperation();
     func->emitRemark("Testing function");

mlir/test/lib/Analysis/TestMemRefBoundCheck.cpp

 
 using namespace mlir;
 
 namespace {
 
 /// Checks for out of bound memref access subscripts..
 struct TestMemRefBoundCheck
     : public PassWrapper<TestMemRefBoundCheck, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestMemRefBoundCheck)
+
   StringRef getArgument() const final { return "test-memref-bound-check"; }
   StringRef getDescription() const final {
     return "Check memref access bounds";
   }
   void runOnOperation() override;
 };
 
 } // namespace

mlir/test/lib/Analysis/TestMemRefDependenceCheck.cpp

 using namespace mlir;
 
 namespace {
 
 // TODO: Add common surrounding loop depth-wise dependence checks.
 /// Checks dependences between all pairs of memref accesses in a Function.
 struct TestMemRefDependenceCheck
     : public PassWrapper<TestMemRefDependenceCheck, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestMemRefDependenceCheck)
+
   StringRef getArgument() const final { return "test-memref-dependence-check"; }
   StringRef getDescription() const final {
     return "Checks dependences between all pairs of memref accesses.";
   }
   SmallVector<Operation *, 4> loadsAndStores;
   void runOnOperation() override;
 };
 

mlir/test/lib/Analysis/TestMemRefStrideCalculation.cpp

 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 struct TestMemRefStrideCalculation
     : public PassWrapper<TestMemRefStrideCalculation,
                          InterfacePass<SymbolOpInterface>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestMemRefStrideCalculation)
+
   StringRef getArgument() const final {
     return "test-memref-stride-calculation";
   }
   StringRef getDescription() const final {
     return "Test operation constant folding";
   }
   void runOnOperation() override;
 };

mlir/test/lib/Analysis/TestSlice.cpp

 
 static const StringLiteral kOrderMarker = "__test_sort_original_idx__";
 
 namespace {
 
 struct TestTopologicalSortPass
     : public PassWrapper<TestTopologicalSortPass,
                          InterfacePass<SymbolOpInterface>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestTopologicalSortPass)
+
   StringRef getArgument() const final { return "test-print-topological-sort"; }
   StringRef getDescription() const final {
     return "Print operations in topological order";
   }
   void runOnOperation() override {
     std::map<int, Operation *> ops;
     getOperation().walk([&ops](Operation *op) {
       if (auto originalOrderAttr = op->getAttrOfType<IntegerAttr>(kOrderMarker))

mlir/test/lib/Conversion/FuncToLLVM/TestConvertCallOp.cpp

public:
   LogicalResult
   matchAndRewrite(test::TestTypeProducerOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<LLVM::NullOp>(op, getVoidPtrType());
     return success();
   }
 };
 
-class TestConvertCallOp
+struct TestConvertCallOp
     : public PassWrapper<TestConvertCallOp, OperationPass<ModuleOp>> {
-public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestConvertCallOp)
+
   void getDependentDialects(DialectRegistry &registry) const final {
     registry.insert<LLVM::LLVMDialect>();
   }
   StringRef getArgument() const final { return "test-convert-call-op"; }
   StringRef getDescription() const final {
     return "Tests conversion of `func.call` to `llvm.call` in "
            "presence of custom types";
   }

mlir/test/lib/Dialect/Affine/TestAffineDataCopy.cpp

 #define PASS_NAME "test-affine-data-copy"
 
 using namespace mlir;
 
 namespace {
 
 struct TestAffineDataCopy
     : public PassWrapper<TestAffineDataCopy, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestAffineDataCopy)
+
   StringRef getArgument() const final { return PASS_NAME; }
   StringRef getDescription() const final {
     return "Tests affine data copy utility functions.";
   }
   TestAffineDataCopy() = default;
   TestAffineDataCopy(const TestAffineDataCopy &pass) : PassWrapper(pass){};
 
   void getDependentDialects(DialectRegistry &registry) const override {

mlir/test/lib/Dialect/Affine/TestAffineLoopParametricTiling.cpp

 using namespace mlir;
 
 #define DEBUG_TYPE "test-affine-parametric-tile"
 
 namespace {
 struct TestAffineLoopParametricTiling
     : public PassWrapper<TestAffineLoopParametricTiling,
                          OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestAffineLoopParametricTiling)
+
   StringRef getArgument() const final { return "test-affine-parametric-tile"; }
   StringRef getDescription() const final {
     return "Tile affine loops using SSA values as tile sizes";
   }
   void runOnOperation() override;
 };
 } // namespace
 

mlir/test/lib/Dialect/Affine/TestAffineLoopUnswitching.cpp

 
 using namespace mlir;
 
 namespace {
 
 /// This pass applies the permutation on the first maximal perfect nest.
 struct TestAffineLoopUnswitching
     : public PassWrapper<TestAffineLoopUnswitching, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestAffineLoopUnswitching)
+
   StringRef getArgument() const final { return PASS_NAME; }
   StringRef getDescription() const final {
     return "Tests affine loop unswitching / if/else hoisting";
   }
   TestAffineLoopUnswitching() = default;
   TestAffineLoopUnswitching(const TestAffineLoopUnswitching &pass) = default;
 
   void runOnOperation() override;

mlir/test/lib/Dialect/Affine/TestLoopFusion.cpp

static llvm::cl::opt<bool> clTestLoopFusionTransformation(
     "test-loop-fusion-transformation",
     llvm::cl::desc("Enable testing of loop fusion transformation"),
     llvm::cl::cat(clOptionsCategory));
 
 namespace {
 
 struct TestLoopFusion
     : public PassWrapper<TestLoopFusion, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLoopFusion)
+
   StringRef getArgument() const final { return "test-loop-fusion"; }
   StringRef getDescription() const final {
     return "Tests loop fusion utility functions.";
   }
   void runOnOperation() override;
 };
 
 } // namespace

mlir/test/lib/Dialect/Affine/TestLoopMapping.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/Pass/Pass.h"
 
 #include "llvm/ADT/SetVector.h"
 
 using namespace mlir;
 
 namespace {
-class TestLoopMappingPass
+struct TestLoopMappingPass
     : public PassWrapper<TestLoopMappingPass, OperationPass<>> {
-public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLoopMappingPass)
+
   StringRef getArgument() const final {
     return "test-mapping-to-processing-elements";
   }
   StringRef getDescription() const final {
     return "test mapping a single loop on a virtual processor grid";
   }
   explicit TestLoopMappingPass() = default;
 

mlir/test/lib/Dialect/Affine/TestLoopPermutation.cpp

 
 using namespace mlir;
 
 namespace {
 
 /// This pass applies the permutation on the first maximal perfect nest.
 struct TestLoopPermutation
     : public PassWrapper<TestLoopPermutation, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLoopPermutation)
+
   StringRef getArgument() const final { return PASS_NAME; }
   StringRef getDescription() const final {
     return "Tests affine loop permutation utility";
   }
   TestLoopPermutation() = default;
   TestLoopPermutation(const TestLoopPermutation &pass) : PassWrapper(pass){};
 
   void runOnOperation() override;

mlir/test/lib/Dialect/Affine/TestVectorizationUtils.cpp

static llvm::cl::opt<bool> clTestVecAffineLoopNest(
     llvm::cl::desc(
         "Enable testing for the 'vectorizeAffineLoopNest' utility by "
         "vectorizing the outermost loops found"),
     llvm::cl::cat(clOptionsCategory));
 
 namespace {
 struct VectorizerTestPass
     : public PassWrapper<VectorizerTestPass, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(VectorizerTestPass)
+
   static constexpr auto kTestAffineMapOpName = "test_affine_map";
   static constexpr auto kTestAffineMapAttrName = "affine_map";
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<vector::VectorDialect>();
   }
   StringRef getArgument() const final { return "affine-super-vectorizer-test"; }
   StringRef getDescription() const final {
     return "Tests vectorizer standalone functionality.";

mlir/test/lib/Dialect/DLTI/TestDataLayoutQuery.cpp

 
 namespace {
 
 /// A pass that finds "test.data_layout_query" operations and attaches to them
 /// attributes containing the results of data layout queries for operation
 /// result types.
 struct TestDataLayoutQuery
     : public PassWrapper<TestDataLayoutQuery, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestDataLayoutQuery)
+
   StringRef getArgument() const final { return "test-data-layout-query"; }
   StringRef getDescription() const final { return "Test data layout queries"; }
   void runOnOperation() override {
     FuncOp func = getOperation();
     Builder builder(func.getContext());
     const DataLayoutAnalysis &layouts = getAnalysis<DataLayoutAnalysis>();
 
     func.walk([&](test::DataLayoutQueryOp op) {

mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp

 namespace {
 /// A pass for testing call graph type decomposition.
 ///
 /// This instantiates the patterns with a TypeConverter and ValueDecomposer
 /// that splits tuple types into their respective element types.
 /// For example, `tuple<T1, T2, T3> --> T1, T2, T3`.
 struct TestDecomposeCallGraphTypes
     : public PassWrapper<TestDecomposeCallGraphTypes, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestDecomposeCallGraphTypes)
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<test::TestDialect>();
   }
   StringRef getArgument() const final {
     return "test-decompose-call-graph-types";
   }
   StringRef getDescription() const final {

mlir/test/lib/Dialect/GPU/TestConvertGPUKernelToCubin.cpp

 
 using namespace mlir;
 
 #if MLIR_CUDA_CONVERSIONS_ENABLED
 namespace {
 class TestSerializeToCubinPass
     : public PassWrapper<TestSerializeToCubinPass, gpu::SerializeToBlobPass> {
 public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestSerializeToCubinPass)
+
   StringRef getArgument() const final { return "test-gpu-to-cubin"; }
   StringRef getDescription() const final {
     return "Lower GPU kernel function to CUBIN binary annotations";
   }
   TestSerializeToCubinPass();
 
 private:
   void getDependentDialects(DialectRegistry &registry) const override;

mlir/test/lib/Dialect/GPU/TestConvertGPUKernelToHsaco.cpp

 
 using namespace mlir;
 
 #if MLIR_ROCM_CONVERSIONS_ENABLED
 namespace {
 class TestSerializeToHsacoPass
     : public PassWrapper<TestSerializeToHsacoPass, gpu::SerializeToBlobPass> {
 public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestSerializeToHsacoPass)
+
   StringRef getArgument() const final { return "test-gpu-to-hsaco"; }
   StringRef getDescription() const final {
     return "Lower GPU kernel function to HSAco binary annotations";
   }
   TestSerializeToHsacoPass();
 
 private:
   void getDependentDialects(DialectRegistry &registry) const override;

mlir/test/lib/Dialect/GPU/TestGpuMemoryPromotion.cpp

 
 using namespace mlir;
 
 namespace {
 /// Simple pass for testing the promotion to workgroup memory in GPU functions.
 /// Promotes all arguments with "gpu.test_promote_workgroup" attribute. This
 /// does not check whether the promotion is legal (e.g., amount of memory used)
 /// or beneficial (e.g., makes previously uncoalesced loads coalesced).
-class TestGpuMemoryPromotionPass
+struct TestGpuMemoryPromotionPass
     : public PassWrapper<TestGpuMemoryPromotionPass,
                          OperationPass<gpu::GPUFuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestGpuMemoryPromotionPass)
+
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, memref::MemRefDialect, scf::SCFDialect>();
   }
   StringRef getArgument() const final { return "test-gpu-memory-promotion"; }
   StringRef getDescription() const final {
     return "Promotes the annotated arguments of gpu.func to workgroup memory.";
   }
 

mlir/test/lib/Dialect/GPU/TestGpuParallelLoopMapping.cpp

 #include "mlir/Dialect/GPU/ParallelLoopMapper.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 /// Simple pass for testing the mapping of parallel loops to hardware ids using
 /// a greedy mapping strategy.
-class TestGpuGreedyParallelLoopMappingPass
+struct TestGpuGreedyParallelLoopMappingPass
     : public PassWrapper<TestGpuGreedyParallelLoopMappingPass,
                          OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestGpuGreedyParallelLoopMappingPass)
+
   StringRef getArgument() const final {
     return "test-gpu-greedy-parallel-loop-mapping";
   }
   StringRef getDescription() const final {
     return "Greedily maps all parallel loops to gpu hardware ids.";
   }
   void runOnOperation() override {
     for (Region &region : getOperation()->getRegions())

mlir/test/lib/Dialect/GPU/TestGpuRewrite.cpp

 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 namespace {
 struct TestGpuRewritePass
     : public PassWrapper<TestGpuRewritePass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestGpuRewritePass)
+
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<arith::ArithmeticDialect, func::FuncDialect,
                     memref::MemRefDialect>();
   }
   StringRef getArgument() const final { return "test-gpu-rewrite"; }
   StringRef getDescription() const final {
     return "Applies all rewrite patterns within the GPU dialect.";
   }

mlir/test/lib/Dialect/Linalg/TestLinalgCodegenStrategy.cpp

 #include "llvm/ADT/SetVector.h"
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 namespace {
 struct TestLinalgCodegenStrategy
     : public PassWrapper<TestLinalgCodegenStrategy, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLinalgCodegenStrategy)
+
   StringRef getArgument() const final { return "test-linalg-codegen-strategy"; }
   StringRef getDescription() const final {
     return "Test Linalg Codegen Strategy.";
   }
   TestLinalgCodegenStrategy() = default;
   TestLinalgCodegenStrategy(const TestLinalgCodegenStrategy &pass)
       : PassWrapper(pass) {}
 

mlir/test/lib/Dialect/Linalg/TestLinalgElementwiseFusion.cpp

 
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/ADT/TypeSwitch.h"
 
-namespace mlir {
+using namespace mlir;
 
 static void addOperands(Operation *op, SetVector<Value> &operandSet) {
   if (!op)
     return;
   TypeSwitch<Operation *, void>(op)
       .Case<linalg::LinalgOp>([&](linalg::LinalgOp linalgOp) {
         SmallVector<Value> inputOperands = linalgOp.getInputOperands();
         operandSet.insert(inputOperands.begin(), inputOperands.end());
static bool setFusedOpOperandLimit(const OpResult &producer,
   fusedOpOperands.remove(producer);
   addOperands(producer.getOwner(), fusedOpOperands);
   return fusedOpOperands.size() <= limit;
 }
 
 namespace {
 struct TestLinalgElementwiseFusion
     : public PassWrapper<TestLinalgElementwiseFusion, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLinalgElementwiseFusion)
+
   TestLinalgElementwiseFusion() = default;
   TestLinalgElementwiseFusion(const TestLinalgElementwiseFusion &pass)
       : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
                     tensor::TensorDialect>();
   }
   StringRef getArgument() const final {
if (fuseWithReshapeByCollapsingWithControlFn) {
       linalg::populateFoldReshapeOpsByCollapsingPatterns(patterns, controlFn);
       (void)applyPatternsAndFoldGreedily(funcOp.getBody(), std::move(patterns));
     }
   }
 };
 
 } // namespace
 
+namespace mlir {
 namespace test {
 void registerTestLinalgElementwiseFusion() {
   PassRegistration<TestLinalgElementwiseFusion>();
 }
 } // namespace test
-
 } // namespace mlir

mlir/test/lib/Dialect/Linalg/TestLinalgFusionTransforms.cpp

patterns.add<LinalgTileAndFusePattern<GenericOp>>(
           StringAttr::get(context, "after_transpose_fusion_original")));
 }
 
 namespace {
 template <LinalgTilingLoopType LoopType>
 struct TestLinalgFusionTransforms
     : public PassWrapper<TestLinalgFusionTransforms<LoopType>,
                          OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLinalgFusionTransforms)
+
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
                     scf::SCFDialect>();
   }
   TestLinalgFusionTransforms() = default;
   TestLinalgFusionTransforms(const TestLinalgFusionTransforms &pass) {}
 
   void runOnOperation() override {
     MLIRContext *context = &this->getContext();
     FuncOp funcOp = this->getOperation();
     RewritePatternSet fusionPatterns(context);
     Aliases alias;
     LinalgDependenceGraph dependenceGraph =
         LinalgDependenceGraph::buildDependenceGraph(alias, funcOp);
     fillFusionPatterns<LoopType>(context, dependenceGraph, fusionPatterns);
     (void)applyPatternsAndFoldGreedily(funcOp, std::move(fusionPatterns));
   }
 };
 
 struct TestLinalgFusionTransformsParallelLoops
     : public TestLinalgFusionTransforms<LinalgTilingLoopType::ParallelLoops> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestLinalgFusionTransformsParallelLoops)
+
   StringRef getArgument() const final {
     return "test-linalg-fusion-transform-patterns";
   }
   StringRef getDescription() const final {
     return "Test Linalg fusion transformation patterns by applying them "
            "greedily.";
   }
 };
 
 struct TestLinalgFusionTransformsLoops
     : public TestLinalgFusionTransforms<LinalgTilingLoopType::Loops> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLinalgFusionTransformsLoops)
+
   StringRef getArgument() const final {
     return "test-linalg-tensor-fusion-transform-patterns";
   }
   StringRef getDescription() const final {
     return "Test Linalg on tensor fusion transformation "
            "patterns by applying them greedily.";
   }
 };
 
 struct TestLinalgFusionTransformsTiledLoops
     : public TestLinalgFusionTransforms<LinalgTilingLoopType::TiledLoops> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestLinalgFusionTransformsTiledLoops)
+
   StringRef getArgument() const final {
     return "test-linalg-tiled-loop-fusion-transform-patterns";
   }
   StringRef getDescription() const final {
     return "Test Linalg on tensor fusion transformation "
            "patterns by applying them greedily.";
   }
 };
for (auto *e : eraseSet)
     e->erase();
 
   return changed ? success() : failure();
 }
 
 namespace {
 struct TestLinalgGreedyFusion
     : public PassWrapper<TestLinalgGreedyFusion, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLinalgGreedyFusion)
+
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
                     scf::SCFDialect>();
   }
   StringRef getArgument() const final { return "test-linalg-greedy-fusion"; }
   StringRef getDescription() const final {
     return "Test Linalg fusion by applying a greedy test transformation.";
   }
struct TestLinalgGreedyFusion
   }
 };
 
 /// Pass to test tile and fuse of sequence of operations. Intended only for
 /// testing.
 struct TestLinalgTileAndFuseSequencePass
     : public PassWrapper<TestLinalgTileAndFuseSequencePass,
                          OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestLinalgTileAndFuseSequencePass)
+
   StringRef getArgument() const final { return "test-linalg-tile-and-fuse"; }
   StringRef getDescription() const final {
     return "Test Linalg tiling and fusion of a sequence of Linalg operations.";
   }
   TestLinalgTileAndFuseSequencePass() = default;
   TestLinalgTileAndFuseSequencePass(
       const TestLinalgTileAndFuseSequencePass &pass)
       : PassWrapper(pass){};

mlir/test/lib/Dialect/Linalg/TestLinalgHoisting.cpp

 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 namespace {
 struct TestLinalgHoisting
     : public PassWrapper<TestLinalgHoisting, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLinalgHoisting)
+
   TestLinalgHoisting() = default;
   TestLinalgHoisting(const TestLinalgHoisting &pass) : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect>();
   }
   StringRef getArgument() const final { return "test-linalg-hoisting"; }
   StringRef getDescription() const final {
     return "Test Linalg hoisting functions.";

mlir/test/lib/Dialect/Linalg/TestLinalgTransforms.cpp

 #include "llvm/ADT/SmallVector.h"
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 namespace {
 struct TestLinalgTransforms
     : public PassWrapper<TestLinalgTransforms, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLinalgTransforms)
+
   TestLinalgTransforms() = default;
   TestLinalgTransforms(const TestLinalgTransforms &pass) : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     // clang-format off
     registry.insert<AffineDialect,
                     memref::MemRefDialect,
                     scf::SCFDialect,

mlir/test/lib/Dialect/Linalg/TestPadFusion.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
-namespace mlir {
+using namespace mlir;
 
 namespace {
 struct TestPadFusionPass
     : public PassWrapper<TestPadFusionPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestPadFusionPass)
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry
         .insert<AffineDialect, linalg::LinalgDialect, tensor::TensorDialect>();
   }
 
   StringRef getArgument() const final { return "test-linalg-pad-fusion"; }
   StringRef getDescription() const final { return "Test PadOp fusion"; }
 
   void runOnOperation() override {
     MLIRContext *context = &getContext();
     RewritePatternSet patterns(context);
     linalg::populateFuseTensorPadWithProducerLinalgOpPatterns(patterns);
     if (failed(
             applyPatternsAndFoldGreedily(getOperation(), std::move(patterns))))
       return signalPassFailure();
   }
 };
 } // namespace
 
+namespace mlir {
 namespace test {
 void registerTestPadFusion() { PassRegistration<TestPadFusionPass>(); }
 } // namespace test
-
 } // namespace mlir

mlir/test/lib/Dialect/Math/TestAlgebraicSimplification.cpp

 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 namespace {
 struct TestMathAlgebraicSimplificationPass
     : public PassWrapper<TestMathAlgebraicSimplificationPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestMathAlgebraicSimplificationPass)
+
   void runOnOperation() override;
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<vector::VectorDialect, math::MathDialect>();
   }
   StringRef getArgument() const final {
     return "test-math-algebraic-simplification";
   }
   StringRef getDescription() const final {

mlir/test/lib/Dialect/Math/TestExpandTanh.cpp

 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 namespace {
 struct TestExpandTanhPass
     : public PassWrapper<TestExpandTanhPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestExpandTanhPass)
+
   void runOnOperation() override;
   StringRef getArgument() const final { return "test-expand-tanh"; }
   StringRef getDescription() const final { return "Test expanding tanh"; }
 };
 } // namespace
 
 void TestExpandTanhPass::runOnOperation() {
   RewritePatternSet patterns(&getContext());

mlir/test/lib/Dialect/Math/TestPolynomialApproximation.cpp

 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 namespace {
 struct TestMathPolynomialApproximationPass
     : public PassWrapper<TestMathPolynomialApproximationPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestMathPolynomialApproximationPass)
+
   TestMathPolynomialApproximationPass() = default;
   TestMathPolynomialApproximationPass(
       const TestMathPolynomialApproximationPass &pass)
       : PassWrapper(pass) {}
 
   void runOnOperation() override;
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<arith::ArithmeticDialect, math::MathDialect,

mlir/test/lib/Dialect/MemRef/TestComposeSubView.cpp

 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 namespace {
 struct TestComposeSubViewPass
     : public PassWrapper<TestComposeSubViewPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestComposeSubViewPass)
+
   StringRef getArgument() const final { return "test-compose-subview"; }
   StringRef getDescription() const final {
     return "Test combining composed subviews";
   }
   void runOnOperation() override;
   void getDependentDialects(DialectRegistry &registry) const override;
 };
 

mlir/test/lib/Dialect/MemRef/TestMultiBuffer.cpp

 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 struct TestMultiBufferingPass
     : public PassWrapper<TestMultiBufferingPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestMultiBufferingPass)
+
   TestMultiBufferingPass() = default;
   TestMultiBufferingPass(const TestMultiBufferingPass &pass)
       : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect>();
   }
   StringRef getArgument() const final { return "test-multi-buffering"; }
   StringRef getDescription() const final {

mlir/test/lib/Dialect/SCF/TestLoopParametricTiling.cpp

 
 namespace {
 
 // Extracts fixed-range loops for top-level loop nests with ranges defined in
 // the pass constructor.  Assumes loops are permutable.
 class SimpleParametricLoopTilingPass
     : public PassWrapper<SimpleParametricLoopTilingPass, OperationPass<>> {
 public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SimpleParametricLoopTilingPass)
+
   StringRef getArgument() const final {
     return "test-extract-fixed-outer-loops";
   }
   StringRef getDescription() const final {
     return "test application of parametric tiling to the outer loops so that "
            "the ranges of outer loops become static";
   }
   SimpleParametricLoopTilingPass() = default;

mlir/test/lib/Dialect/SCF/TestLoopUnrolling.cpp

static unsigned getNestingDepth(Operation *op) {
   unsigned depth = 0;
   while ((currOp = currOp->getParentOp())) {
     if (isa<scf::ForOp>(currOp))
       depth++;
   }
   return depth;
 }
 
-class TestLoopUnrollingPass
+struct TestLoopUnrollingPass
     : public PassWrapper<TestLoopUnrollingPass, OperationPass<>> {
-public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLoopUnrollingPass)
+
   StringRef getArgument() const final { return "test-loop-unrolling"; }
   StringRef getDescription() const final {
     return "Tests loop unrolling transformation";
   }
   TestLoopUnrollingPass() = default;
   TestLoopUnrollingPass(const TestLoopUnrollingPass &) {}
   explicit TestLoopUnrollingPass(uint64_t unrollFactorParam,
                                  unsigned loopDepthParam,

mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp

 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 #include "llvm/ADT/SetVector.h"
 
 using namespace mlir;
 
 namespace {
-class TestSCFForUtilsPass
+struct TestSCFForUtilsPass
     : public PassWrapper<TestSCFForUtilsPass, OperationPass<FuncOp>> {
-public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestSCFForUtilsPass)
+
   StringRef getArgument() const final { return "test-scf-for-utils"; }
   StringRef getDescription() const final { return "test scf.for utils"; }
   explicit TestSCFForUtilsPass() = default;
 
   void runOnOperation() override {
     FuncOp func = getOperation();
     SmallVector<scf::ForOp, 4> toErase;
 
func.walk([&](Operation *fakeRead) {
           newLoop.getResults().take_back()[0]);
       toErase.push_back(loop);
     });
     for (auto loop : llvm::reverse(toErase))
       loop.erase();
   }
 };
 
-class TestSCFIfUtilsPass
+struct TestSCFIfUtilsPass
     : public PassWrapper<TestSCFIfUtilsPass, OperationPass<ModuleOp>> {
-public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestSCFIfUtilsPass)
+
   StringRef getArgument() const final { return "test-scf-if-utils"; }
   StringRef getDescription() const final { return "test scf.if utils"; }
   explicit TestSCFIfUtilsPass() = default;
 
   void runOnOperation() override {
     int count = 0;
     getOperation().walk([&](scf::IfOp ifOp) {
       auto strCount = std::to_string(count++);

 static const StringLiteral kTestPipeliningOpOrderMarker =
     "__test_pipelining_op_order__";
 
 static const StringLiteral kTestPipeliningAnnotationPart =
     "__test_pipelining_part";
 static const StringLiteral kTestPipeliningAnnotationIteration =
     "__test_pipelining_iteration";
 
-class TestSCFPipeliningPass
+struct TestSCFPipeliningPass
     : public PassWrapper<TestSCFPipeliningPass, OperationPass<FuncOp>> {
-public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestSCFPipeliningPass)
+
   TestSCFPipeliningPass() = default;
   TestSCFPipeliningPass(const TestSCFPipeliningPass &) {}
   StringRef getArgument() const final { return "test-scf-pipelining"; }
   StringRef getDescription() const final { return "test scf.forOp pipelining"; }
 
   Option<bool> annotatePipeline{
       *this, "annotate",
       llvm::cl::desc("Annote operations during loop pipelining transformation"),

mlir/test/lib/Dialect/SPIRV/TestAvailability.cpp

 //===----------------------------------------------------------------------===//
 // Printing op availability pass
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// A pass for testing SPIR-V op availability.
 struct PrintOpAvailability
     : public PassWrapper<PrintOpAvailability, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PrintOpAvailability)
+
   void runOnOperation() override;
   StringRef getArgument() const final { return "test-spirv-op-availability"; }
   StringRef getDescription() const final {
     return "Test SPIR-V op availability";
   }
 };
 } // namespace
 

 //===----------------------------------------------------------------------===//
 // Converting target environment pass
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// A pass for testing SPIR-V op availability.
 struct ConvertToTargetEnv
     : public PassWrapper<ConvertToTargetEnv, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ConvertToTargetEnv)
+
   StringRef getArgument() const override { return "test-spirv-target-env"; }
   StringRef getDescription() const override {
     return "Test SPIR-V target environment";
   }
   void runOnOperation() override;
 };
 
 struct ConvertToAtomCmpExchangeWeak : public RewritePattern {

mlir/test/lib/Dialect/SPIRV/TestEntryPointAbi.cpp

 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 /// Pass to set the spv.entry_point_abi
-class TestSpirvEntryPointABIPass
+struct TestSpirvEntryPointABIPass
     : public PassWrapper<TestSpirvEntryPointABIPass,
                          OperationPass<gpu::GPUModuleOp>> {
-public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestSpirvEntryPointABIPass)
+
   StringRef getArgument() const final { return "test-spirv-entry-point-abi"; }
   StringRef getDescription() const final {
     return "Set the spv.entry_point_abi attribute on GPU kernel function "
            "within the "
            "module, intended for testing only";
   }
   TestSpirvEntryPointABIPass() = default;
   TestSpirvEntryPointABIPass(const TestSpirvEntryPointABIPass &) {}

mlir/test/lib/Dialect/SPIRV/TestModuleCombiner.cpp

 
 using namespace mlir;
 
 namespace {
 class TestModuleCombinerPass
     : public PassWrapper<TestModuleCombinerPass,
                          OperationPass<mlir::ModuleOp>> {
 public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestModuleCombinerPass)
+
   StringRef getArgument() const final { return "test-spirv-module-combiner"; }
   StringRef getDescription() const final {
     return "Tests SPIR-V module combiner library";
   }
   TestModuleCombinerPass() = default;
   TestModuleCombinerPass(const TestModuleCombinerPass &) {}
   void runOnOperation() override;
 

mlir/test/lib/Dialect/Shape/TestShapeFunctions.cpp

 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 /// This is a pass that reports shape functions associated with ops.
 struct ReportShapeFnPass
     : public PassWrapper<ReportShapeFnPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ReportShapeFnPass)
+
   void runOnOperation() override;
   StringRef getArgument() const final { return "test-shape-function-report"; }
   StringRef getDescription() const final {
     return "Test pass to report associated shape functions";
   }
 };
 } // namespace
 

mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp

 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 namespace {
 struct TestTensorTransforms
     : public PassWrapper<TestTensorTransforms, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestTensorTransforms)
+
   TestTensorTransforms() = default;
   TestTensorTransforms(const TestTensorTransforms &pass) : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<arith::ArithmeticDialect, scf::SCFDialect>();
   }
 
   StringRef getArgument() const final {

mlir/test/lib/Dialect/Test/TestDialect.cpp

 
 //===----------------------------------------------------------------------===//
 // Test SideEffect interfaces
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// A test resource for side effects.
 struct TestResource : public SideEffects::Resource::Base<TestResource> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestResource)
+
   StringRef getName() final { return "<Test>"; }
 };
 } // namespace
 
 static void testSideEffectOpGetEffect(
     Operation *op,
     SmallVectorImpl<SideEffects::EffectInstance<TestEffects::Effect>>
         &effects) {

mlir/test/lib/Dialect/Test/TestPatterns.cpp

if (!matchPattern(operand->getOperand(1), m_Constant(&constInput)))
       return failure();
     rewriter.replaceOp(op, operand->getOperand(1));
     return success();
   }
 };
 
 struct TestPatternDriver
     : public PassWrapper<TestPatternDriver, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestPatternDriver)
+
   StringRef getArgument() const final { return "test-patterns"; }
   StringRef getDescription() const final { return "Run test dialect patterns"; }
   void runOnOperation() override {
     mlir::RewritePatternSet patterns(&getContext());
     populateWithGenerated(patterns);
 
     // Verify named pattern is generated with expected name.
     patterns.add<FoldingPattern, TestNamedPatternRule,
static void reifyReturnShape(Operation *op) {
   for (const auto &it : llvm::enumerate(shapes)) {
     op->emitRemark() << "value " << it.index() << ": "
                      << it.value().getDefiningOp();
   }
 }
 
 struct TestReturnTypeDriver
     : public PassWrapper<TestReturnTypeDriver, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestReturnTypeDriver)
+
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<tensor::TensorDialect>();
   }
   StringRef getArgument() const final { return "test-return-type"; }
   StringRef getDescription() const final { return "Run return type functions"; }
 
   void runOnOperation() override {
     if (getOperation().getName() == "testCreateFunctions") {
void runOnOperation() override {
     }
   }
 };
 } // namespace
 
 namespace {
 struct TestDerivedAttributeDriver
     : public PassWrapper<TestDerivedAttributeDriver, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestDerivedAttributeDriver)
+
   StringRef getArgument() const final { return "test-derived-attr"; }
   StringRef getDescription() const final {
     return "Run test derived attributes";
   }
   void runOnOperation() override;
 };
 } // namespace
 
struct TestTypeConverter : public TypeConverter {
   static Optional<Value> materializeCast(OpBuilder &builder, Type resultType,
                                          ValueRange inputs, Location loc) {
     return builder.create<TestCastOp>(loc, resultType, inputs).getResult();
   }
 };
 
 struct TestLegalizePatternDriver
     : public PassWrapper<TestLegalizePatternDriver, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLegalizePatternDriver)
+
   StringRef getArgument() const final { return "test-legalize-patterns"; }
   StringRef getDescription() const final {
     return "Run test dialect legalization patterns";
   }
   /// The mode of conversion to use with the driver.
   enum class ConversionMode { Analysis, Full, Partial };
 
   TestLegalizePatternDriver(ConversionMode mode) : mode(mode) {}
matchAndRewrite(TestRemappedValueRegionOp op, OpAdaptor adaptor,
     rewriter.eraseOp(terminator);
     rewriter.replaceOp(op, terminatorOperands);
     return success();
   }
 };
 
 struct TestRemappedValue
     : public mlir::PassWrapper<TestRemappedValue, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestRemappedValue)
+
   StringRef getArgument() const final { return "test-remapped-value"; }
   StringRef getDescription() const final {
     return "Test public remapped value mechanism in ConversionPatternRewriter";
   }
   void runOnOperation() override {
     TestRemapValueTypeConverter typeConverter;
 
     mlir::RewritePatternSet patterns(&getContext());
if (!isa<TestDialect>(op->getDialect()))
       return failure();
     rewriter.eraseOp(op);
     return success();
   }
 };
 
 struct TestUnknownRootOpDriver
     : public mlir::PassWrapper<TestUnknownRootOpDriver, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestUnknownRootOpDriver)
+
   StringRef getArgument() const final {
     return "test-legalize-unknown-root-patterns";
   }
   StringRef getDescription() const final {
     return "Test public remapped value mechanism in ConversionPatternRewriter";
   }
   void runOnOperation() override {
     mlir::RewritePatternSet patterns(&getContext());
LogicalResult matchAndRewrite(TestAnotherTypeProducerOp op,
                                 PatternRewriter &rewriter) const final {
     rewriter.replaceOpWithNewOp<TestTypeProducerOp>(op, op.getType());
     return success();
   }
 };
 
 struct TestTypeConversionDriver
     : public PassWrapper<TestTypeConversionDriver, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestTypeConversionDriver)
+
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<TestDialect>();
   }
   StringRef getArgument() const final {
     return "test-legalize-type-conversion";
   }
   StringRef getDescription() const final {
     return "Test various type conversion functionalities in DialectConversion";
matchAndRewrite(TestTypeChangerOp op, OpAdaptor adaptor,
     rewriter.replaceOp(op, adaptor.getOperands());
     return success();
   }
 };
 
 struct TestTargetMaterializationWithNoUses
     : public PassWrapper<TestTargetMaterializationWithNoUses,
                          OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestTargetMaterializationWithNoUses)
+
   StringRef getArgument() const final {
     return "test-target-materialization-with-no-uses";
   }
   StringRef getDescription() const final {
     return "Test a special case of target materialization in DialectConversion";
   }
 
   void runOnOperation() override {
matchAndRewrite(SingleBlockImplicitTerminatorOp op, OpAdaptor adaptor,
     rewriter.updateRootInPlace(op, [] {});
     return success();
   }
 };
 
 struct TestMergeBlocksPatternDriver
     : public PassWrapper<TestMergeBlocksPatternDriver,
                          OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestMergeBlocksPatternDriver)
+
   StringRef getArgument() const final { return "test-merge-blocks"; }
   StringRef getDescription() const final {
     return "Test Merging operation in ConversionPatternRewriter";
   }
   void runOnOperation() override {
     MLIRContext *context = &getContext();
     mlir::RewritePatternSet patterns(context);
     patterns.add<TestMergeBlock, TestUndoBlocksMerge, TestMergeSingleBlockOps>(
LogicalResult matchAndRewrite(TestCastOp op,
     rewriter.replaceOp(op, op.getOperand(1));
     return success();
   }
 };
 
 struct TestSelectiveReplacementPatternDriver
     : public PassWrapper<TestSelectiveReplacementPatternDriver,
                          OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestSelectiveReplacementPatternDriver)
+
   StringRef getArgument() const final {
     return "test-pattern-selective-replacement";
   }
   StringRef getDescription() const final {
     return "Test selective replacement in the PatternRewriter";
   }
   void runOnOperation() override {
     MLIRContext *context = &getContext();

mlir/test/lib/Dialect/Test/TestTraits.cpp

OpFoldResult TestInvolutionTraitSuccesfulOperationFolderOp::fold(
   auto argumentOp = getOperand();
   // The success case should cause the trait fold to be supressed.
   return argumentOp.getDefiningOp() ? argumentOp : OpFoldResult{};
 }
 
 namespace {
 struct TestTraitFolder
     : public PassWrapper<TestTraitFolder, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestTraitFolder)
+
   StringRef getArgument() const final { return "test-trait-folder"; }
   StringRef getDescription() const final { return "Run trait folding"; }
   void runOnOperation() override {
     (void)applyPatternsAndFoldGreedily(getOperation(),
                                        RewritePatternSet(&getContext()));
   }
 };
 } // namespace
 
 namespace mlir {
 void registerTestTraitsPass() { PassRegistration<TestTraitFolder>(); }
 } // namespace mlir

mlir/test/lib/Dialect/Tosa/TosaTestPasses.cpp

ConvertTosaConv2DOp::matchAndRewrite(Operation *op,
   rewriter.replaceOp(op, {newTosaRescaleOp.getResult()});
   return success();
 }
 
 namespace {
 
 struct TosaTestQuantUtilAPI
     : public PassWrapper<TosaTestQuantUtilAPI, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TosaTestQuantUtilAPI)
+
   StringRef getArgument() const final { return PASS_NAME; }
   StringRef getDescription() const final {
     return "TOSA Test: Exercise the APIs in QuantUtils.cpp.";
   }
   void runOnOperation() override;
 };
 
 void TosaTestQuantUtilAPI::runOnOperation() {

mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp

 using namespace mlir;
 using namespace mlir::linalg;
 using namespace mlir::vector;
 
 namespace {
 
 struct TestVectorToVectorLowering
     : public PassWrapper<TestVectorToVectorLowering, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestVectorToVectorLowering)
+
   TestVectorToVectorLowering() = default;
   TestVectorToVectorLowering(const TestVectorToVectorLowering &pass)
       : PassWrapper(pass) {}
   StringRef getArgument() const final {
     return "test-vector-to-vector-lowering";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns between ops in the vector dialect";
private:
   static LogicalResult filter(Operation *op) {
     return success(isa<arith::AddFOp, arith::SelectOp, arith::CmpFOp,
                        ContractionOp, TransferReadOp, TransferWriteOp>(op));
   }
 };
 
 struct TestVectorContractionLowering
     : public PassWrapper<TestVectorContractionLowering, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestVectorContractionLowering)
+
   StringRef getArgument() const final {
     return "test-vector-contraction-lowering";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns that lower contract ops in the vector "
            "dialect";
   }
   TestVectorContractionLowering() = default;
void runOnOperation() override {
     populateVectorMaskOpLoweringPatterns(patterns);
     populateVectorShapeCastLoweringPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorTransposeLowering
     : public PassWrapper<TestVectorTransposeLowering, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestVectorTransposeLowering)
+
   StringRef getArgument() const final {
     return "test-vector-transpose-lowering";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns that lower contract ops in the vector "
            "dialect";
   }
   TestVectorTransposeLowering() = default;
void runOnOperation() override {
     dynamicPM.addPass(createLinalgStrategyLowerVectorsPass(options));
     if (failed(runPipeline(dynamicPM, getOperation())))
       return signalPassFailure();
   }
 };
 
 struct TestVectorUnrollingPatterns
     : public PassWrapper<TestVectorUnrollingPatterns, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestVectorUnrollingPatterns)
+
   StringRef getArgument() const final {
     return "test-vector-unrolling-patterns";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to unroll contract ops in the vector "
            "dialect";
   }
   TestVectorUnrollingPatterns() = default;
struct TestVectorUnrollingPatterns
   Option<bool> unrollBasedOnType{
       *this, "unroll-based-on-type",
       llvm::cl::desc("Set the unroll factor based on type of the operation"),
       llvm::cl::init(false)};
 };
 
 struct TestVectorDistributePatterns
     : public PassWrapper<TestVectorDistributePatterns, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestVectorDistributePatterns)
+
   StringRef getArgument() const final {
     return "test-vector-distribute-patterns";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to distribute vector ops in the vector "
            "dialect";
   }
   TestVectorDistributePatterns() = default;
void runOnOperation() override {
     });
     populatePropagateVectorDistributionPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorToLoopPatterns
     : public PassWrapper<TestVectorToLoopPatterns, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestVectorToLoopPatterns)
+
   StringRef getArgument() const final { return "test-vector-to-forloop"; }
   StringRef getDescription() const final {
     return "Test lowering patterns to break up a vector op into a for loop";
   }
   TestVectorToLoopPatterns() = default;
   TestVectorToLoopPatterns(const TestVectorToLoopPatterns &pass)
       : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
void runOnOperation() override {
     populatePropagateVectorDistributionPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorTransferUnrollingPatterns
     : public PassWrapper<TestVectorTransferUnrollingPatterns,
                          OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestVectorTransferUnrollingPatterns)
+
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect>();
   }
   StringRef getArgument() const final {
     return "test-vector-transfer-unrolling-patterns";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to unroll transfer ops in the vector "
void runOnOperation() override {
     populateVectorToVectorCanonicalizationPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorTransferFullPartialSplitPatterns
     : public PassWrapper<TestVectorTransferFullPartialSplitPatterns,
                          OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestVectorTransferFullPartialSplitPatterns)
+
   StringRef getArgument() const final {
     return "test-vector-transfer-full-partial-split";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to split "
            "transfer ops via scf.if + linalg ops";
   }
   TestVectorTransferFullPartialSplitPatterns() = default;
else
       options.setVectorTransferSplit(VectorTransferSplit::VectorTransfer);
     patterns.add<VectorTransferFullPartialRewriter>(ctx, options);
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorTransferOpt
     : public PassWrapper<TestVectorTransferOpt, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestVectorTransferOpt)
+
   StringRef getArgument() const final { return "test-vector-transferop-opt"; }
   StringRef getDescription() const final {
     return "Test optimization transformations for transfer ops";
   }
   void runOnOperation() override { transferOpflowOpt(getOperation()); }
 };
 
 struct TestVectorTransferLoweringPatterns
     : public PassWrapper<TestVectorTransferLoweringPatterns,
                          OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestVectorTransferLoweringPatterns)
+
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<tensor::TensorDialect, memref::MemRefDialect>();
   }
   StringRef getArgument() const final {
     return "test-vector-transfer-lowering-patterns";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to lower transfer ops to other vector ops";
   }
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateVectorTransferLoweringPatterns(patterns);
     populateVectorTransferPermutationMapLoweringPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorMultiReductionLoweringPatterns
     : public PassWrapper<TestVectorMultiReductionLoweringPatterns,
                          OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestVectorMultiReductionLoweringPatterns)
+
   TestVectorMultiReductionLoweringPatterns() = default;
   TestVectorMultiReductionLoweringPatterns(
       const TestVectorMultiReductionLoweringPatterns &pass)
       : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
   StringRef getArgument() const final {
populateVectorMultiReductionLoweringPatterns(
                       : vector::VectorMultiReductionLowering::InnerReduction);
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorTransferCollapseInnerMostContiguousDims
     : public PassWrapper<TestVectorTransferCollapseInnerMostContiguousDims,
                          OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestVectorTransferCollapseInnerMostContiguousDims)
+
   TestVectorTransferCollapseInnerMostContiguousDims() = default;
   TestVectorTransferCollapseInnerMostContiguousDims(
       const TestVectorTransferCollapseInnerMostContiguousDims &pass) = default;
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect, AffineDialect>();
   }
 
void runOnOperation() override {
     populateVectorTransferCollapseInnerMostContiguousDimsPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorReduceToContractPatternsPatterns
     : public PassWrapper<TestVectorReduceToContractPatternsPatterns,
                          OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestVectorReduceToContractPatternsPatterns)
+
   StringRef getArgument() const final {
     return "test-vector-reduction-to-contract-patterns";
   }
   StringRef getDescription() const final {
     return "Test patterns to convert multireduce op to contract and combine "
            "broadcast/transpose to contract";
   }
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateVectorReductionToContractPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorTransferDropUnitDimsPatterns
     : public PassWrapper<TestVectorTransferDropUnitDimsPatterns,
                          OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestVectorTransferDropUnitDimsPatterns)
+
   StringRef getArgument() const final {
     return "test-vector-transfer-drop-unit-dims-patterns";
   }
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateVectorTransferDropUnitDimsPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestFlattenVectorTransferPatterns
     : public PassWrapper<TestFlattenVectorTransferPatterns,
                          OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestFlattenVectorTransferPatterns)
+
   StringRef getArgument() const final {
     return "test-vector-transfer-flatten-patterns";
   }
   StringRef getDescription() const final {
     return "Test patterns to rewrite contiguous row-major N-dimensional "
            "vector.transfer_{read,write} ops into 1D transfers";
   }
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateFlattenVectorTransferPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct TestVectorScanLowering
     : public PassWrapper<TestVectorScanLowering, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestVectorScanLowering)
+
   StringRef getArgument() const final { return "test-vector-scan-lowering"; }
   StringRef getDescription() const final {
     return "Test lowering patterns that lower the scan op in the vector "
            "dialect";
   }
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateVectorScanLoweringPatterns(patterns);

mlir/test/lib/IR/TestBuiltinAttributeInterfaces.cpp

 #include "llvm/Support/FormatVariadic.h"
 
 using namespace mlir;
 using namespace test;
 
 namespace {
 struct TestElementsAttrInterface
     : public PassWrapper<TestElementsAttrInterface, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestElementsAttrInterface)
+
   StringRef getArgument() const final { return "test-elements-attr-interface"; }
   StringRef getDescription() const final {
     return "Test ElementsAttr interface support.";
   }
   void runOnOperation() override {
     getOperation().walk([&](Operation *op) {
       for (NamedAttribute attr : op->getAttrs()) {
         auto elementsAttr = attr.getValue().dyn_cast<ElementsAttr>();

mlir/test/lib/IR/TestDiagnostics.cpp

 #include "llvm/Support/SourceMgr.h"
 
 using namespace mlir;
 
 namespace {
 struct TestDiagnosticFilterPass
     : public PassWrapper<TestDiagnosticFilterPass,
                          InterfacePass<SymbolOpInterface>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestDiagnosticFilterPass)
+
   StringRef getArgument() const final { return "test-diagnostic-filter"; }
   StringRef getDescription() const final {
     return "Test diagnostic filtering support.";
   }
   TestDiagnosticFilterPass() = default;
   TestDiagnosticFilterPass(const TestDiagnosticFilterPass &) {}
 
   void runOnOperation() override {

mlir/test/lib/IR/TestDominance.cpp

 
 private:
   Operation *operation;
   DenseMap<Block *, size_t> blockIds;
 };
 
 struct TestDominancePass
     : public PassWrapper<TestDominancePass, InterfacePass<SymbolOpInterface>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestDominancePass)
+
   StringRef getArgument() const final { return "test-print-dominance"; }
   StringRef getDescription() const final {
     return "Print the dominance information for multiple regions.";
   }
 
   void runOnOperation() override {
     llvm::errs() << "Testing : " << getOperation().getName() << "\n";
     DominanceTest dominanceTest(getOperation());

mlir/test/lib/IR/TestFunc.cpp

 
 using namespace mlir;
 
 namespace {
 /// This is a test pass for verifying FunctionOpInterface's insertArgument
 /// method.
 struct TestFuncInsertArg
     : public PassWrapper<TestFuncInsertArg, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestFuncInsertArg)
+
   StringRef getArgument() const final { return "test-func-insert-arg"; }
   StringRef getDescription() const final { return "Test inserting func args."; }
   void runOnOperation() override {
     auto module = getOperation();
 
     UnknownLoc unknownLoc = UnknownLoc::get(module.getContext());
     for (auto func : module.getOps<FunctionOpInterface>()) {
       auto inserts = func->getAttrOfType<ArrayAttr>("test.insert_args");
for (auto func : module.getOps<FunctionOpInterface>()) {
                            locsToInsert);
     }
   }
 };
 
 /// This is a test pass for verifying FunctionOpInterface's insertResult method.
 struct TestFuncInsertResult
     : public PassWrapper<TestFuncInsertResult, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestFuncInsertResult)
+
   StringRef getArgument() const final { return "test-func-insert-result"; }
   StringRef getDescription() const final {
     return "Test inserting func results.";
   }
   void runOnOperation() override {
     auto module = getOperation();
 
     for (auto func : module.getOps<FunctionOpInterface>()) {
void runOnOperation() override {
     }
   }
 };
 
 /// This is a test pass for verifying FunctionOpInterface's eraseArgument
 /// method.
 struct TestFuncEraseArg
     : public PassWrapper<TestFuncEraseArg, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestFuncEraseArg)
+
   StringRef getArgument() const final { return "test-func-erase-arg"; }
   StringRef getDescription() const final { return "Test erasing func args."; }
   void runOnOperation() override {
     auto module = getOperation();
 
     for (auto func : module.getOps<FunctionOpInterface>()) {
       BitVector indicesToErase(func.getNumArguments());
       for (auto argIndex : llvm::seq<int>(0, func.getNumArguments()))
         if (func.getArgAttr(argIndex, "test.erase_this_arg"))
           indicesToErase.set(argIndex);
       func.eraseArguments(indicesToErase);
     }
   }
 };
 
 /// This is a test pass for verifying FunctionOpInterface's eraseResult method.
 struct TestFuncEraseResult
     : public PassWrapper<TestFuncEraseResult, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestFuncEraseResult)
+
   StringRef getArgument() const final { return "test-func-erase-result"; }
   StringRef getDescription() const final {
     return "Test erasing func results.";
   }
   void runOnOperation() override {
     auto module = getOperation();
 
     for (auto func : module.getOps<FunctionOpInterface>()) {
       BitVector indicesToErase(func.getNumResults());
       for (auto resultIndex : llvm::seq<int>(0, func.getNumResults()))
         if (func.getResultAttr(resultIndex, "test.erase_this_result"))
           indicesToErase.set(resultIndex);
       func.eraseResults(indicesToErase);
     }
   }
 };
 
 /// This is a test pass for verifying FunctionOpInterface's setType method.
 struct TestFuncSetType
     : public PassWrapper<TestFuncSetType, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestFuncSetType)
+
   StringRef getArgument() const final { return "test-func-set-type"; }
   StringRef getDescription() const final {
     return "Test FunctionOpInterface::setType.";
   }
   void runOnOperation() override {
     auto module = getOperation();
     SymbolTable symbolTable(module);
 

mlir/test/lib/IR/TestInterfaces.cpp

 using namespace mlir;
 using namespace test;
 
 namespace {
 /// This test checks various aspects of Type interface generation and
 /// application.
 struct TestTypeInterfaces
     : public PassWrapper<TestTypeInterfaces, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestTypeInterfaces)
+
   StringRef getArgument() const final { return "test-type-interfaces"; }
   StringRef getDescription() const final {
     return "Test type interface support.";
   }
   void runOnOperation() override {
     getOperation().walk([](Operation *op) {
       for (Type type : op->getResultTypes()) {
         if (auto testInterface = type.dyn_cast<TestTypeInterface>()) {

mlir/test/lib/IR/TestMatchers.cpp

 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 /// This is a test pass for verifying matchers.
 struct TestMatchers
     : public PassWrapper<TestMatchers, InterfacePass<FunctionOpInterface>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestMatchers)
+
   void runOnOperation() override;
   StringRef getArgument() const final { return "test-matchers"; }
   StringRef getDescription() const final {
     return "Test C++ pattern matchers.";
   }
 };
 } // namespace
 

mlir/test/lib/IR/TestOpaqueLoc.cpp

 //===- TestOpaqueLoc.cpp - Pass to test opaque locations ------------------===//
 //
 // 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/IR/Builders.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
+/// A simple structure which is used for testing as an underlying location in
+/// OpaqueLoc.
+struct MyLocation {
+  MyLocation() = default;
+  MyLocation(int id) : id(id) {}
+  int getId() { return id; }
+
+  int id{42};
+};
+} // namespace
+
+MLIR_DECLARE_EXPLICIT_TYPE_ID(MyLocation *)
+MLIR_DEFINE_EXPLICIT_TYPE_ID(MyLocation *)
+
+namespace {
 /// Pass that changes locations to opaque locations for each operation.
 /// It also takes all operations that are not function operations or
 /// terminators and clones them with opaque locations which store the initial
 /// locations.
 struct TestOpaqueLoc
     : public PassWrapper<TestOpaqueLoc, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestOpaqueLoc)
+
   StringRef getArgument() const final { return "test-opaque-loc"; }
   StringRef getDescription() const final {
     return "Changes all leaf locations to opaque locations";
   }
 
-  /// A simple structure which is used for testing as an underlying location in
-  /// OpaqueLoc.
-  struct MyLocation {
-    MyLocation() = default;
-    MyLocation(int id) : id(id) {}
-    int getId() { return id; }
-
-    int id{42};
-  };
-
   void runOnOperation() override {
     std::vector<std::unique_ptr<MyLocation>> myLocs;
     int lastIt = 0;
 
     getOperation().getBody()->walk([&](Operation *op) {
       myLocs.push_back(std::make_unique<MyLocation>(lastIt++));
 
       Location loc = op->getLoc();

mlir/test/lib/IR/TestOperationEquals.cpp

 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 /// This pass illustrates the IR def-use chains through printing.
 struct TestOperationEqualPass
     : public PassWrapper<TestOperationEqualPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestOperationEqualPass)
+
   StringRef getArgument() const final { return "test-operations-equality"; }
   StringRef getDescription() const final { return "Test operations equality."; }
   void runOnOperation() override {
     ModuleOp module = getOperation();
     // Expects two operations at the top-level:
     int opCount = module.getBody()->getOperations().size();
     if (opCount != 2) {
       module.emitError() << "expected 2 top-level ops in the module, got "

mlir/test/lib/IR/TestPrintDefUse.cpp

 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 /// This pass illustrates the IR def-use chains through printing.
 struct TestPrintDefUsePass
     : public PassWrapper<TestPrintDefUsePass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestPrintDefUsePass)
+
   StringRef getArgument() const final { return "test-print-defuse"; }
   StringRef getDescription() const final { return "Test various printing."; }
   void runOnOperation() override {
     // Recursively traverse the IR nested under the current operation and print
     // every single operation and their operands and users.
     getOperation()->walk([](Operation *op) {
       llvm::outs() << "Visiting op '" << op->getName() << "' with "
                    << op->getNumOperands() << " operands:\n";

mlir/test/lib/IR/TestPrintInvalid.cpp

 #include "mlir/Pass/Pass.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
 
 namespace {
 struct TestPrintInvalidPass
     : public PassWrapper<TestPrintInvalidPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestPrintInvalidPass)
+
   StringRef getArgument() const final { return "test-print-invalid"; }
   StringRef getDescription() const final {
     return "Test printing invalid ops.";
   }
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<func::FuncDialect>();
   }
 

mlir/test/lib/IR/TestPrintNesting.cpp

 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 /// This pass illustrates the IR nesting through printing.
 struct TestPrintNestingPass
     : public PassWrapper<TestPrintNestingPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestPrintNestingPass)
+
   StringRef getArgument() const final { return "test-print-nesting"; }
   StringRef getDescription() const final { return "Test various printing."; }
   // Entry point for the pass.
   void runOnOperation() override {
     Operation *op = getOperation();
     resetIndent();
     printOperation(op);
   }

mlir/test/lib/IR/TestSideEffects.cpp

 //===- TestSidEffects.cpp - Pass to test side effects ---------------------===//
 //
 // 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 "TestDialect.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 struct SideEffectsPass
     : public PassWrapper<SideEffectsPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SideEffectsPass)
+
   StringRef getArgument() const final { return "test-side-effects"; }
   StringRef getDescription() const final {
     return "Test side effects interfaces";
   }
   void runOnOperation() override {
     auto module = getOperation();
 
     // Walk operations detecting side effects.

mlir/test/lib/IR/TestSlicing.cpp

static LogicalResult createBackwardSliceFunction(Operation *op,
   builder.create<func::ReturnOp>(loc);
   return success();
 }
 
 namespace {
 /// Pass to test slice generated from slice analysis.
 struct SliceAnalysisTestPass
     : public PassWrapper<SliceAnalysisTestPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SliceAnalysisTestPass)
+
   StringRef getArgument() const final { return "slice-analysis-test"; }
   StringRef getDescription() const final {
     return "Test Slice analysis functionality.";
   }
   void runOnOperation() override;
   SliceAnalysisTestPass() = default;
   SliceAnalysisTestPass(const SliceAnalysisTestPass &) {}
 };

mlir/test/lib/IR/TestSymbolUses.cpp

 
 using namespace mlir;
 
 namespace {
 /// This is a symbol test pass that tests the symbol uselist functionality
 /// provided by the symbol table along with erasing from the symbol table.
 struct SymbolUsesPass
     : public PassWrapper<SymbolUsesPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SymbolUsesPass)
+
   StringRef getArgument() const final { return "test-symbol-uses"; }
   StringRef getDescription() const final {
     return "Test detection of symbol uses";
   }
   WalkResult operateOnSymbol(Operation *symbol, ModuleOp module,
                              SmallVectorImpl<FuncOp> &deadFunctions) {
     // Test computing uses on a non symboltable op.
     Optional<SymbolTable::UseRange> symbolUses =
void runOnOperation() override {
     }
   }
 };
 
 /// This is a symbol test pass that tests the symbol use replacement
 /// functionality provided by the symbol table.
 struct SymbolReplacementPass
     : public PassWrapper<SymbolReplacementPass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SymbolReplacementPass)
+
   StringRef getArgument() const final { return "test-symbol-rauw"; }
   StringRef getDescription() const final {
     return "Test replacement of symbol uses";
   }
   void runOnOperation() override {
     ModuleOp module = getOperation();
 
     // Don't try to replace if we can't collect symbol uses.

mlir/test/lib/IR/TestTypes.cpp

 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 using namespace test;
 
 namespace {
 struct TestRecursiveTypesPass
     : public PassWrapper<TestRecursiveTypesPass, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestRecursiveTypesPass)
+
   LogicalResult createIRWithTypes();
 
   StringRef getArgument() const final { return "test-recursive-types"; }
   StringRef getDescription() const final {
     return "Test support for recursive types";
   }
   void runOnOperation() override {
     FuncOp func = getOperation();

mlir/test/lib/IR/TestVisitors.cpp

static void testNoSkipErasureCallbacks(Operation *op) {
   cloned->walk<WalkOrder::PostOrder>(noSkipBlockErasure);
   cloned->erase();
 }
 
 namespace {
 /// This pass exercises the different configurations of the IR visitors.
 struct TestIRVisitorsPass
     : public PassWrapper<TestIRVisitorsPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestIRVisitorsPass)
+
   StringRef getArgument() const final { return "test-ir-visitors"; }
   StringRef getDescription() const final { return "Test various visitors."; }
   void runOnOperation() override {
     Operation *op = getOperation();
     testPureCallbacks(op);
     testSkipErasureCallbacks(op);
     testNoSkipErasureCallbacks(op);
   }
 };
 } // namespace
 
 namespace mlir {
 namespace test {
 void registerTestIRVisitorsPass() { PassRegistration<TestIRVisitorsPass>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/IR/TestVisitorsGeneric.cpp

static std::string getStageDescription(const WalkStage &stage) {
   if (stage.isAfterAllRegions())
     return "after all regions";
   return "before region #" + std::to_string(stage.getNextRegion());
 }
 
 namespace {
 /// This pass exercises generic visitor with void callbacks and prints the order
 /// and stage in which operations are visited.
-class TestGenericIRVisitorPass
+struct TestGenericIRVisitorPass
     : public PassWrapper<TestGenericIRVisitorPass, OperationPass<>> {
-public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestGenericIRVisitorPass)
+
   StringRef getArgument() const final { return "test-generic-ir-visitors"; }
   StringRef getDescription() const final { return "Test generic IR visitors."; }
   void runOnOperation() override {
     Operation *outerOp = getOperation();
     int stepNo = 0;
     outerOp->walk([&](Operation *op, const WalkStage &stage) {
       llvm::outs() << "step " << stepNo++ << " op '" << op->getName() << "' "
                    << getStageDescription(stage) << "\n";
     });
 
     // Exercise static inference of operation type.
     outerOp->walk([&](test::TwoRegionOp op, const WalkStage &stage) {
       llvm::outs() << "step " << stepNo++ << " op '" << op->getName() << "' "
                    << getStageDescription(stage) << "\n";
     });
   }
 };
 
 /// This pass exercises the generic visitor with non-void callbacks and prints
 /// the order and stage in which operations are visited. It will interrupt the
 /// walk based on attributes peesent in the IR.
-class TestGenericIRVisitorInterruptPass
+struct TestGenericIRVisitorInterruptPass
     : public PassWrapper<TestGenericIRVisitorInterruptPass, OperationPass<>> {
-public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
+      TestGenericIRVisitorInterruptPass)
+
   StringRef getArgument() const final {
     return "test-generic-ir-visitors-interrupt";
   }
   StringRef getDescription() const final {
     return "Test generic IR visitors with interrupts.";
   }
   void runOnOperation() override {
     Operation *outerOp = getOperation();

mlir/test/lib/Pass/TestDynamicPipeline.cpp

 
 using namespace mlir;
 
 namespace {
 
 class TestDynamicPipelinePass
     : public PassWrapper<TestDynamicPipelinePass, OperationPass<>> {
 public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestDynamicPipelinePass)
+
   StringRef getArgument() const final { return "test-dynamic-pipeline"; }
   StringRef getDescription() const final {
     return "Tests the dynamic pipeline feature by applying "
            "a pipeline on a selected set of functions";
   }
   void getDependentDialects(DialectRegistry &registry) const override {
     OpPassManager pm(ModuleOp::getOperationName(),
                      OpPassManager::Nesting::Implicit);

mlir/test/lib/Pass/TestPassManager.cpp

 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 
 using namespace mlir;
 
 namespace {
 struct TestModulePass
     : public PassWrapper<TestModulePass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestModulePass)
+
   void runOnOperation() final {}
   StringRef getArgument() const final { return "test-module-pass"; }
   StringRef getDescription() const final {
     return "Test a module pass in the pass manager";
   }
 };
 struct TestFunctionPass
     : public PassWrapper<TestFunctionPass, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestFunctionPass)
+
   void runOnOperation() final {}
   StringRef getArgument() const final { return "test-function-pass"; }
   StringRef getDescription() const final {
     return "Test a function pass in the pass manager";
   }
 };
-class TestInterfacePass
+struct TestInterfacePass
     : public PassWrapper<TestInterfacePass,
                          InterfacePass<FunctionOpInterface>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestInterfacePass)
+
   void runOnOperation() final {
     getOperation()->emitRemark() << "Executing interface pass on operation";
   }
   StringRef getArgument() const final { return "test-interface-pass"; }
   StringRef getDescription() const final {
     return "Test an interface pass (running on FunctionOpInterface) in the "
            "pass manager";
   }
 };
-class TestOptionsPass
+struct TestOptionsPass
     : public PassWrapper<TestOptionsPass, OperationPass<FuncOp>> {
-public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestOptionsPass)
+
   struct Options : public PassPipelineOptions<Options> {
     ListOption<int> listOption{*this, "list",
                                llvm::cl::desc("Example list option")};
     ListOption<std::string> stringListOption{
         *this, "string-list", llvm::cl::desc("Example string list option")};
     Option<std::string> stringOption{*this, "string",
                                      llvm::cl::desc("Example string option")};
   };
struct TestOptionsPass
   ListOption<std::string> stringListOption{
       *this, "string-list", llvm::cl::desc("Example string list option")};
   Option<std::string> stringOption{*this, "string",
                                    llvm::cl::desc("Example string option")};
 };
 
 /// A test pass that always aborts to enable testing the crash recovery
 /// mechanism of the pass manager.
-class TestCrashRecoveryPass
+struct TestCrashRecoveryPass
     : public PassWrapper<TestCrashRecoveryPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestCrashRecoveryPass)
+
   void runOnOperation() final { abort(); }
   StringRef getArgument() const final { return "test-pass-crash"; }
   StringRef getDescription() const final {
     return "Test a pass in the pass manager that always crashes";
   }
 };
 
 /// A test pass that always fails to enable testing the failure recovery
 /// mechanisms of the pass manager.
-class TestFailurePass : public PassWrapper<TestFailurePass, OperationPass<>> {
+struct TestFailurePass : public PassWrapper<TestFailurePass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestFailurePass)
+
   void runOnOperation() final { signalPassFailure(); }
   StringRef getArgument() const final { return "test-pass-failure"; }
   StringRef getDescription() const final {
     return "Test a pass in the pass manager that always fails";
   }
 };
 
 /// A test pass that always fails to enable testing the failure recovery
 /// mechanisms of the pass manager.
-class TestInvalidParentPass
+struct TestInvalidParentPass
     : public PassWrapper<TestInvalidParentPass,
                          InterfacePass<FunctionOpInterface>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestInvalidParentPass)
+
   StringRef getArgument() const final { return "test-pass-invalid-parent"; }
   StringRef getDescription() const final {
     return "Test a pass in the pass manager that makes the parent operation "
            "invalid";
   }
   void getDependentDialects(DialectRegistry &registry) const final {
     registry.insert<test::TestDialect>();
   }
   void runOnOperation() final {
     FunctionOpInterface op = getOperation();
     OpBuilder b(getOperation().getBody());
     b.create<test::TestCallOp>(op.getLoc(), TypeRange(), "some_unknown_func",
                                ValueRange());
   }
 };
 
 /// A test pass that contains a statistic.
 struct TestStatisticPass
     : public PassWrapper<TestStatisticPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestStatisticPass)
+
   TestStatisticPass() = default;
   TestStatisticPass(const TestStatisticPass &) {}
   StringRef getArgument() const final { return "test-stats-pass"; }
   StringRef getDescription() const final { return "Test pass statistics"; }
 
   Statistic opCount{this, "num-ops", "Number of operations counted"};
 
   void runOnOperation() final {

mlir/test/lib/Reducer/MLIRTestReducer.cpp

 using namespace mlir;
 
 namespace {
 
 /// This pass looks for for the presence of an operation with the name
 /// "crashOp" in the input MLIR file and crashes the mlir-opt tool if the
 /// operation is found.
 struct TestReducer : public PassWrapper<TestReducer, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestReducer)
+
   StringRef getArgument() const final { return "test-mlir-reducer"; }
   StringRef getDescription() const final {
     return "Tests MLIR Reduce tool by generating failures";
   }
   void runOnOperation() override;
 };
 
 } // namespace

mlir/test/lib/Rewrite/TestPDLByteCode.cpp

static void customRewriter(ArrayRef<PDLValue> args, PatternRewriter &rewriter,
   successOpState.addOperands(args[1].cast<Value>());
   rewriter.create(successOpState);
   rewriter.eraseOp(root);
 }
 
 namespace {
 struct TestPDLByteCodePass
     : public PassWrapper<TestPDLByteCodePass, OperationPass<ModuleOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestPDLByteCodePass)
+
   StringRef getArgument() const final { return "test-pdl-bytecode-pass"; }
   StringRef getDescription() const final {
     return "Test PDL ByteCode functionality";
   }
   void getDependentDialects(DialectRegistry &registry) const override {
     // Mark the pdl_interp dialect as a dependent. This is needed, because we
     // create ops from that dialect as a part of the PDL-to-PDLInterp lowering.
     registry.insert<pdl_interp::PDLInterpDialect>();

mlir/test/lib/Transforms/TestConstantFold.cpp

 #include "mlir/Transforms/FoldUtils.h"
 
 using namespace mlir;
 
 namespace {
 /// Simple constant folding pass.
 struct TestConstantFold
     : public PassWrapper<TestConstantFold, OperationPass<>> {
+  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;
 
   void foldOperation(Operation *op, OperationFolder &helper);

mlir/test/lib/Transforms/TestControlFlowSink.cpp

 using namespace mlir;
 
 namespace {
 /// An example control-flow sink pass to test the control-flow sink utilites.
 /// This pass will sink ops named `test.sink_me` and tag them with an attribute
 /// `was_sunk` into the first region of `test.sink_target` ops.
 struct TestControlFlowSinkPass
     : public PassWrapper<TestControlFlowSinkPass, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestControlFlowSinkPass)
+
   /// Get the command-line argument of the test pass.
   StringRef getArgument() const final { return "test-control-flow-sink"; }
   /// Get the description of the test pass.
   StringRef getDescription() const final {
     return "Test control-flow sink pass";
   }
 
   /// Runs the pass on the function.

mlir/test/lib/Transforms/TestInlining.cpp

 #include "mlir/Transforms/InliningUtils.h"
 #include "llvm/ADT/StringSet.h"
 
 using namespace mlir;
 using namespace test;
 
 namespace {
 struct Inliner : public PassWrapper<Inliner, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(Inliner)
+
   StringRef getArgument() const final { return "test-inline"; }
   StringRef getDescription() const final {
     return "Test inlining region calls";
   }
 
   void runOnOperation() override {
     auto function = getOperation();
 

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

if (defs.empty())
     // Emit the declarations.
     for (const AttrOrTypeDef &def : defs)
       DefGen(def).emitDecl(os);
   }
   // Emit the TypeID explicit specializations to have a single definition for
   // each of these.
   for (const AttrOrTypeDef &def : defs)
     if (!def.getDialect().getCppNamespace().empty())
-      os << "DECLARE_EXPLICIT_TYPE_ID(" << def.getDialect().getCppNamespace()
-         << "::" << def.getCppClassName() << ")\n";
+      os << "MLIR_DECLARE_EXPLICIT_TYPE_ID("
+         << def.getDialect().getCppNamespace() << "::" << def.getCppClassName()
+         << ")\n";
 
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // GEN: Def List
 //===----------------------------------------------------------------------===//
 
bool DefGenerator::emitDefs(StringRef selectedDialect) {
   for (const AttrOrTypeDef &def : defs) {
     {
       NamespaceEmitter ns(os, def.getDialect());
       DefGen gen(def);
       gen.emitDef(os);
     }
     // Emit the TypeID explicit specializations to have a single symbol def.
     if (!def.getDialect().getCppNamespace().empty())
-      os << "DEFINE_EXPLICIT_TYPE_ID(" << def.getDialect().getCppNamespace()
-         << "::" << def.getCppClassName() << ")\n";
+      os << "MLIR_DEFINE_EXPLICIT_TYPE_ID("
+         << def.getDialect().getCppNamespace() << "::" << def.getCppClassName()
+         << ")\n";
   }
 
   Dialect firstDialect = defs.front().getDialect();
   // Emit the default parser/printer for Attributes if the dialect asked for
   // it.
   if (valueType == "Attribute" && needsDialectParserPrinter &&
       firstDialect.useDefaultAttributePrinterParser()) {
     NamespaceEmitter nsEmitter(os, firstDialect);

mlir/tools/mlir-tblgen/DialectGen.cpp

// Emit all nested namespaces.
     if (llvm::Optional<StringRef> extraDecl =
             dialect.getExtraClassDeclaration())
       os << *extraDecl;
 
     // End the dialect decl.
     os << "};\n";
   }
   if (!dialect.getCppNamespace().empty())
-    os << "DECLARE_EXPLICIT_TYPE_ID(" << dialect.getCppNamespace()
+    os << "MLIR_DECLARE_EXPLICIT_TYPE_ID(" << dialect.getCppNamespace()
        << "::" << dialect.getCppClassName() << ")\n";
 }
 
 static bool emitDialectDecls(const llvm::RecordKeeper &recordKeeper,
                              raw_ostream &os) {
   emitSourceFileHeader("Dialect Declarations", os);
 
   auto dialectDefs = recordKeeper.getAllDerivedDefinitions("Dialect");

 static const char *const dialectDestructorStr = R"(
 {0}::~{0}() = default;
 
 )";
 
 static void emitDialectDef(Dialect &dialect, raw_ostream &os) {
   // Emit the TypeID explicit specializations to have a single symbol def.
   if (!dialect.getCppNamespace().empty())
-    os << "DEFINE_EXPLICIT_TYPE_ID(" << dialect.getCppNamespace()
+    os << "MLIR_DEFINE_EXPLICIT_TYPE_ID(" << dialect.getCppNamespace()
        << "::" << dialect.getCppClassName() << ")\n";
 
   // Emit all nested namespaces.
   NamespaceEmitter nsEmitter(os, dialect);
 
   if (!dialect.hasNonDefaultDestructor())
     os << llvm::formatv(dialectDestructorStr, dialect.getCppClassName());
 }

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

if (emitDecl) {
         NamespaceEmitter emitter(os, op.getCppNamespace());
         os << formatv(opCommentHeader, op.getQualCppClassName(),
                       "declarations");
         OpOperandAdaptorEmitter::emitDecl(op, staticVerifierEmitter, os);
         OpEmitter::emitDecl(op, os, staticVerifierEmitter);
       }
       // Emit the TypeID explicit specialization to have a single definition.
       if (!op.getCppNamespace().empty())
-        os << "DECLARE_EXPLICIT_TYPE_ID(" << op.getCppNamespace()
+        os << "MLIR_DECLARE_EXPLICIT_TYPE_ID(" << op.getCppNamespace()
            << "::" << op.getCppClassName() << ")\n\n";
     } else {
       {
         NamespaceEmitter emitter(os, op.getCppNamespace());
         os << formatv(opCommentHeader, op.getQualCppClassName(), "definitions");
         OpOperandAdaptorEmitter::emitDef(op, staticVerifierEmitter, os);
         OpEmitter::emitDef(op, os, staticVerifierEmitter);
       }
       // Emit the TypeID explicit specialization to have a single definition.
       if (!op.getCppNamespace().empty())
-        os << "DEFINE_EXPLICIT_TYPE_ID(" << op.getCppNamespace()
+        os << "MLIR_DEFINE_EXPLICIT_TYPE_ID(" << op.getCppNamespace()
            << "::" << op.getCppClassName() << ")\n\n";
     }
   }
 }
 
 // Emits a comma-separated list of the ops.
 static void emitOpList(const std::vector<Record *> &defs, raw_ostream &os) {
   IfDefScope scope("GET_OP_LIST", os);

mlir/tools/mlir-tblgen/PassGen.cpp

std::unique_ptr<::mlir::Pass> clonePass() const override {{
     return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
   }
 
   /// Return the dialect that must be loaded in the context before this pass.
   void getDependentDialects(::mlir::DialectRegistry &registry) const override {
     {4}
   }
 
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID({0}Base<DerivedT>)
+
 protected:
 )";
 
 /// Registration for a single dependent dialect, to be inserted for each
 /// dependent dialect in the `getDependentDialects` above.
 const char *const dialectRegistrationTemplate = R"(
   registry.insert<{0}>();
 )";

mlir/unittests/IR/DialectTest.cpp

 #include "mlir/IR/DialectInterface.h"
 #include "gtest/gtest.h"
 
 using namespace mlir;
 using namespace mlir::detail;
 
 namespace {
 struct TestDialect : public Dialect {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestDialect)
+
   static StringRef getDialectNamespace() { return "test"; };
   TestDialect(MLIRContext *context)
       : Dialect(getDialectNamespace(), context, TypeID::get<TestDialect>()) {}
 };
 struct AnotherTestDialect : public Dialect {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(AnotherTestDialect)
+
   static StringRef getDialectNamespace() { return "test"; };
   AnotherTestDialect(MLIRContext *context)
       : Dialect(getDialectNamespace(), context,
                 TypeID::get<AnotherTestDialect>()) {}
 };
 
 TEST(DialectDeathTest, MultipleDialectsWithSameNamespace) {
   MLIRContext context;
 
   // Registering a dialect with the same namespace twice should result in a
   // failure.
   context.loadDialect<TestDialect>();
   ASSERT_DEATH(context.loadDialect<AnotherTestDialect>(), "");
 }
 
 struct SecondTestDialect : public Dialect {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SecondTestDialect)
+
   static StringRef getDialectNamespace() { return "test2"; }
   SecondTestDialect(MLIRContext *context)
       : Dialect(getDialectNamespace(), context,
                 TypeID::get<SecondTestDialect>()) {}
 };
 
 struct TestDialectInterfaceBase
     : public DialectInterface::Base<TestDialectInterfaceBase> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestDialectInterfaceBase)
+
   TestDialectInterfaceBase(Dialect *dialect) : Base(dialect) {}
   virtual int function() const { return 42; }
 };
 
 struct TestDialectInterface : public TestDialectInterfaceBase {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestDialectInterface)
+
   using TestDialectInterfaceBase::TestDialectInterfaceBase;
   int function() const final { return 56; }
 };
 
 struct SecondTestDialectInterface : public TestDialectInterfaceBase {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SecondTestDialectInterface)
+
   using TestDialectInterfaceBase::TestDialectInterfaceBase;
   int function() const final { return 78; }
 };
 
 TEST(Dialect, DelayedInterfaceRegistration) {
   DialectRegistry registry;
   registry.insert<TestDialect, SecondTestDialect>();
 

mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp

 };
 
 /// Simple data layout spec containing a list of entries that always verifies
 /// as valid.
 struct CustomDataLayoutSpec
     : public Attribute::AttrBase<CustomDataLayoutSpec, Attribute,
                                  DataLayoutSpecStorage,
                                  DataLayoutSpecInterface::Trait> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(CustomDataLayoutSpec)
+
   using Base::Base;
   static CustomDataLayoutSpec get(MLIRContext *ctx,
                                   ArrayRef<DataLayoutEntryInterface> entries) {
     return Base::get(ctx, entries);
   }
   CustomDataLayoutSpec
   combineWith(ArrayRef<DataLayoutSpecInterface> specs) const {
     return *this;
   }
   DataLayoutEntryListRef getEntries() const { return getImpl()->entries; }
   LogicalResult verifySpec(Location loc) { return success(); }
 };
 
 /// A type subject to data layout that exits the program if it is queried more
 /// than once. Handy to check if the cache works.
 struct SingleQueryType
     : public Type::TypeBase<SingleQueryType, Type, TypeStorage,
                             DataLayoutTypeInterface::Trait> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SingleQueryType)
+
   using Base::Base;
 
   static SingleQueryType get(MLIRContext *ctx) { return Base::get(ctx); }
 
   unsigned getTypeSizeInBits(const DataLayout &layout,
                              DataLayoutEntryListRef params) const {
     static bool executed = false;
     if (executed)
unsigned getPreferredAlignment(const DataLayout &layout,
 
     executed = true;
     return 4;
   }
 };
 
 /// A types that is not subject to data layout.
 struct TypeNoLayout : public Type::TypeBase<TypeNoLayout, Type, TypeStorage> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TypeNoLayout)
+
   using Base::Base;
 
   static TypeNoLayout get(MLIRContext *ctx) { return Base::get(ctx); }
 };
 
 /// An op that serves as scope for data layout queries with the relevant
 /// attribute attached. This can handle data layout requests for the built-in
 /// types itself.
 struct OpWithLayout : public Op<OpWithLayout, DataLayoutOpInterface::Trait> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OpWithLayout)
+
   using Op::Op;
   static ArrayRef<StringRef> getAttributeNames() { return {}; }
 
   static StringRef getOperationName() { return "dltest.op_with_layout"; }
 
   DataLayoutSpecInterface getDataLayoutSpec() {
     return getOperation()->getAttrOfType<DataLayoutSpecInterface>(kAttrName);
   }
static unsigned getTypePreferredAlignment(Type type,
                                             const DataLayout &dataLayout,
                                             DataLayoutEntryListRef params) {
     return 2 * getTypeABIAlignment(type, dataLayout, params);
   }
 };
 
 struct OpWith7BitByte
     : public Op<OpWith7BitByte, DataLayoutOpInterface::Trait> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OpWith7BitByte)
+
   using Op::Op;
   static ArrayRef<StringRef> getAttributeNames() { return {}; }
 
   static StringRef getOperationName() { return "dltest.op_with_7bit_byte"; }
 
   DataLayoutSpecInterface getDataLayoutSpec() {
     return getOperation()->getAttrOfType<DataLayoutSpecInterface>(kAttrName);
   }
 
   // Bytes are assumed to be 7-bit here.
   static unsigned getTypeSize(Type type, const DataLayout &dataLayout,
                               DataLayoutEntryListRef params) {
     return llvm::divideCeil(dataLayout.getTypeSizeInBits(type), 7);
   }
 };
 
 /// A dialect putting all the above together.
 struct DLTestDialect : Dialect {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(DLTestDialect)
+
   explicit DLTestDialect(MLIRContext *ctx)
       : Dialect(getDialectNamespace(), ctx, TypeID::get<DLTestDialect>()) {
     ctx->getOrLoadDialect<DLTIDialect>();
     addAttributes<CustomDataLayoutSpec>();
     addOperations<OpWithLayout, OpWith7BitByte>();
     addTypes<SingleQueryType, TypeNoLayout>();
   }
   static StringRef getDialectNamespace() { return "dltest"; }

mlir/unittests/Pass/AnalysisManagerTest.cpp

 #include "gtest/gtest.h"
 
 using namespace mlir;
 using namespace mlir::detail;
 
 namespace {
 /// Minimal class definitions for two analyses.
 struct MyAnalysis {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(MyAnalysis)
+
   MyAnalysis(Operation *) {}
 };
 struct OtherAnalysis {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OtherAnalysis)
+
   OtherAnalysis(Operation *) {}
 };
 struct OpSpecificAnalysis {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OpSpecificAnalysis)
+
   OpSpecificAnalysis(ModuleOp) {}
 };
 
 TEST(AnalysisManagerTest, FineGrainModuleAnalysisPreservation) {
   MLIRContext context;
 
   // Test fine grain invalidation of the module analysis manager.
   OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
TEST(AnalysisManagerTest, FineGrainChildFunctionAnalysisPreservation) {
   am.invalidate(pa);
 
   // Check that only MyAnalysis is preserved.
   EXPECT_TRUE(am.getCachedChildAnalysis<MyAnalysis>(func1).hasValue());
   EXPECT_FALSE(am.getCachedChildAnalysis<OtherAnalysis>(func1).hasValue());
 }
 
 /// Test analyses with custom invalidation logic.
-struct TestAnalysisSet {};
+struct TestAnalysisSet {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestAnalysisSet)
+};
 
 struct CustomInvalidatingAnalysis {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(CustomInvalidatingAnalysis)
+
   CustomInvalidatingAnalysis(Operation *) {}
 
   bool isInvalidated(const AnalysisManager::PreservedAnalyses &pa) {
     return !pa.isPreserved<TestAnalysisSet>();
   }
 };
 
 TEST(AnalysisManagerTest, CustomInvalidation) {
TEST(AnalysisManagerTest, OpSpecificAnalysis) {
   AnalysisManager am = mam;
 
   // Query the op specific analysis for the module and verify that its cached.
   am.getAnalysis<OpSpecificAnalysis, ModuleOp>();
   EXPECT_TRUE(am.getCachedAnalysis<OpSpecificAnalysis>().hasValue());
 }
 
 struct AnalysisWithDependency {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(AnalysisWithDependency)
+
   AnalysisWithDependency(Operation *, AnalysisManager &am) {
     am.getAnalysis<MyAnalysis>();
   }
 
   bool isInvalidated(const AnalysisManager::PreservedAnalyses &pa) {
     return !pa.isPreserved<AnalysisWithDependency>() ||
            !pa.isPreserved<MyAnalysis>();
   }
TEST(AnalysisManagerTest, DependentAnalysis) {
   pa.preserve<AnalysisWithDependency>();
   am.invalidate(pa);
 
   EXPECT_FALSE(am.getCachedAnalysis<AnalysisWithDependency>().hasValue());
   EXPECT_FALSE(am.getCachedAnalysis<MyAnalysis>().hasValue());
 }
 
 struct AnalysisWithNestedDependency {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(AnalysisWithNestedDependency)
+
   AnalysisWithNestedDependency(Operation *, AnalysisManager &am) {
     am.getAnalysis<AnalysisWithDependency>();
   }
 
   bool isInvalidated(const AnalysisManager::PreservedAnalyses &pa) {
     return !pa.isPreserved<AnalysisWithNestedDependency>() ||
            !pa.isPreserved<AnalysisWithDependency>();
   }
TEST(AnalysisManagerTest, NestedDependentAnalysis) {
   am.invalidate(pa);
 
   EXPECT_FALSE(am.getCachedAnalysis<AnalysisWithNestedDependency>().hasValue());
   EXPECT_FALSE(am.getCachedAnalysis<AnalysisWithDependency>().hasValue());
   EXPECT_FALSE(am.getCachedAnalysis<MyAnalysis>().hasValue());
 }
 
 struct AnalysisWith2Ctors {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(AnalysisWith2Ctors)
+
   AnalysisWith2Ctors(Operation *) { ctor1called = true; }
 
   AnalysisWith2Ctors(Operation *, AnalysisManager &) { ctor2called = true; }
 
   bool ctor1called = false;
   bool ctor2called = false;
 };
 

mlir/unittests/Pass/PassManagerTest.cpp

 #include <memory>
 
 using namespace mlir;
 using namespace mlir::detail;
 
 namespace {
 /// Analysis that operates on any operation.
 struct GenericAnalysis {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(GenericAnalysis)
+
   GenericAnalysis(Operation *op) : isFunc(isa<FuncOp>(op)) {}
   const bool isFunc;
 };
 
 /// Analysis that operates on a specific operation.
 struct OpSpecificAnalysis {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OpSpecificAnalysis)
+
   OpSpecificAnalysis(FuncOp op) : isSecret(op.getName() == "secret") {}
   const bool isSecret;
 };
 
 /// Simple pass to annotate a FuncOp with the results of analysis.
 struct AnnotateFunctionPass
     : public PassWrapper<AnnotateFunctionPass, OperationPass<FuncOp>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(AnnotateFunctionPass)
+
   void runOnOperation() override {
     FuncOp op = getOperation();
     Builder builder(op->getParentOfType<ModuleOp>());
 
     auto &ga = getAnalysis<GenericAnalysis>();
     auto &sa = getAnalysis<OpSpecificAnalysis>();
 
     op->setAttr("isFunc", builder.getBoolAttr(ga.isFunc));
for (FuncOp func : module->getOps<FuncOp>()) {
     bool isSecret = func.getName() == "secret";
     ASSERT_TRUE(func->getAttr("isSecret").isa<BoolAttr>());
     EXPECT_EQ(func->getAttr("isSecret").cast<BoolAttr>().getValue(), isSecret);
   }
 }
 
 namespace {
 struct InvalidPass : Pass {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(InvalidPass)
+
   InvalidPass() : Pass(TypeID::get<InvalidPass>(), StringRef("invalid_op")) {}
   StringRef getName() const override { return "Invalid Pass"; }
   void runOnOperation() override {}
   bool canScheduleOn(RegisteredOperationName opName) const override {
     return true;
   }
 
   /// A clone method to create a copy of this pass.

mlir/unittests/Transforms/Canonicalizer.cpp

LogicalResult matchAndRewrite(Operation *op,
     if (op->getNumResults() == 1)
       return failure();
     rewriter.eraseOp(op);
     return success();
   }
 };
 
 struct TestDialect : public Dialect {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestDialect)
+
   static StringRef getDialectNamespace() { return "test"; }
 
   TestDialect(MLIRContext *context)
       : Dialect(getDialectNamespace(), context, TypeID::get<TestDialect>()) {
     allowUnknownOperations();
   }
 
   void getCanonicalizationPatterns(RewritePatternSet &results) const override {

mlir/unittests/Transforms/DialectConversion.cpp

static Operation *createOp(MLIRContext *context) {
   context->allowUnregisteredDialects();
   return Operation::create(UnknownLoc::get(context),
                            OperationName("foo.bar", context), llvm::None,
                            llvm::None, llvm::None, llvm::None, 0);
 }
 
 namespace {
 struct DummyOp {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(DummyOp)
+
   static StringRef getOperationName() { return "foo.bar"; }
 };
 
 TEST(DialectConversionTest, DynamicallyLegalOpCallbackOrder) {
   MLIRContext context;
   ConversionTarget target(context);
 
   int index = 0;