[mlir][NFC] Refactor ClassID into a TypeID class.

[rriddle]

Summary

ClassID is a bit janky right now as it involves passing a magic pointer around. This revision hides the internal implementation mechanism within a new class TypeID. This class is a value-typed wrapper around the original ClassID implementation.

[stephenneuendorffer]

Seems like a big change. I don't know if it's worthwhile breaking it down first (like const ClassID * -> TypeID, as a separate change). Might be hard to get the const correctness right, I guess.

mlir/include/mlir/IR/Location.h

280

getTypeID()?

mlir/lib/Dialect/Affine/Transforms/AffineLoopInvariantCodeMotion.cpp

44–45

rename seems unrelated?

mlir/lib/IR/Location.cpp

133

maybe getTypeID()?

[rriddle]

Resolve comments

[rriddle]

In D77768#1970938, @stephenneuendorffer wrote:

Seems like a big change. I don't know if it's worthwhile breaking it down first (like const ClassID * -> TypeID, as a separate change). Might be hard to get the const correctness right, I guess.

Yeah, happy to split it. I mainly wanted one patch to make it easier for me to transfer to my windows machine.

mlir/lib/Dialect/Affine/Transforms/AffineLoopInvariantCodeMotion.cpp

44–45

It's actually not, as the name of this pass matches the one for the other LICM.

[mehdi_amini]

mlir/lib/Dialect/Affine/Transforms/AffineLoopInvariantCodeMotion.cpp

44–45

That has me concerned with the mechanism here if it can't differentiate.

[rriddle]

Remove magic string handling.

[rriddle]

Update

mlir/lib/Dialect/Affine/Transforms/AffineLoopInvariantCodeMotion.cpp

44–45

I discovered a magic incantation to get things to link properly across DLLs, but it requires a combo of dllexport/dllimport which LLVM doesn't even use now. We can punt until linking across DLLs becomes a problem. In the meantime this refactoring is still valuable.

[mehdi_amini]

mlir/include/mlir/Support/TypeID.h

24

I would extend a bit the description with more info about the intended use and how it work.

[rriddle]

Resolve comments. Add more documentation.

mlir/docs/WritingAPass.md

 execute the respective `runAfter*` hook. Below in an example instrumentation
 that counts the number of times DominanceInfo is computed:
 
 ```c++
 struct DominanceCounterInstrumentation : public PassInstrumentation {
   unsigned &count;
 
   DominanceCounterInstrumentation(unsigned &count) : count(count) {}
-  void runAfterAnalysis(llvm::StringRef, AnalysisID *id, Operation *) override {
-    if (id == AnalysisID::getID<DominanceInfo>())
+  void runAfterAnalysis(llvm::StringRef, TypeID id, Operation *) override {
+    if (id == TypeID::get<DominanceInfo>())
       ++count;
   }
 };
 
 MLIRContext *ctx = ...;
 PassManager pm(ctx);
 
 // Add the instrumentation to the pass manager.

mlir/include/mlir/IR/AttributeSupport.h

 // A utility class to get, or create, unique instances of attributes within an
 // MLIRContext. This class manages all creation and uniquing of attributes.
 class AttributeUniquer {
 public:
   /// Get an uniqued instance of attribute T.
   template <typename T, typename... Args>
   static T get(MLIRContext *ctx, unsigned kind, Args &&... args) {
     return ctx->getAttributeUniquer().get<typename T::ImplType>(
-        getInitFn(ctx, T::getClassID()), kind, std::forward<Args>(args)...);
+        getInitFn(ctx, T::getTypeID()), kind, std::forward<Args>(args)...);
   }
 
 private:
   /// Returns a functor used to initialize new attribute storage instances.
-  static std::function<void(AttributeStorage *)>
-  getInitFn(MLIRContext *ctx, const ClassID *const attrID);
+  static std::function<void(AttributeStorage *)> getInitFn(MLIRContext *ctx,
+                                                           TypeID attrID);
 };
 } // namespace detail
 
 } // end namespace mlir
 
 #endif

mlir/include/mlir/IR/Dialect.h

public:
   }
 
   //===--------------------------------------------------------------------===//
   // Interfaces
   //===--------------------------------------------------------------------===//
 
   /// Lookup an interface for the given ID if one is registered, otherwise
   /// nullptr.
-  const DialectInterface *getRegisteredInterface(ClassID *interfaceID) {
+  const DialectInterface *getRegisteredInterface(TypeID interfaceID) {
     auto it = registeredInterfaces.find(interfaceID);
     return it != registeredInterfaces.end() ? it->getSecond().get() : nullptr;
   }
   template <typename InterfaceT> const InterfaceT *getRegisteredInterface() {
     return static_cast<const InterfaceT *>(
         getRegisteredInterface(InterfaceT::getInterfaceID()));
   }
 
template <typename... Args> void addOperations() {
     (void)std::initializer_list<int>{
         0, (addOperation(AbstractOperation::get<Args>(*this)), 0)...};
   }
 
   void addOperation(AbstractOperation opInfo);
 
   /// This method is used by derived classes to add their types to the set.
   template <typename... Args> void addTypes() {
-    (void)std::initializer_list<int>{0, (addSymbol(Args::getClassID()), 0)...};
+    (void)std::initializer_list<int>{0, (addSymbol(Args::getTypeID()), 0)...};
   }
 
   /// This method is used by derived classes to add their attributes to the set.
   template <typename... Args> void addAttributes() {
-    (void)std::initializer_list<int>{0, (addSymbol(Args::getClassID()), 0)...};
+    (void)std::initializer_list<int>{0, (addSymbol(Args::getTypeID()), 0)...};
   }
 
   /// Enable support for unregistered operations.
   void allowUnknownOperations(bool allow = true) { unknownOpsAllowed = allow; }
 
   /// Enable support for unregistered types.
   void allowUnknownTypes(bool allow = true) { unknownTypesAllowed = allow; }
 
   /// Register a dialect interface with this dialect instance.
   void addInterface(std::unique_ptr<DialectInterface> interface);
 
   /// Register a set of dialect interfaces with this dialect instance.
   template <typename... Args> void addInterfaces() {
     (void)std::initializer_list<int>{
         0, (addInterface(std::make_unique<Args>(this)), 0)...};
   }
 
 private:
   // Register a symbol(e.g. type) with its given unique class identifier.
-  void addSymbol(const ClassID *const classID);
+  void addSymbol(TypeID typeID);
 
   Dialect(const Dialect &) = delete;
   void operator=(Dialect &) = delete;
 
   /// Register this dialect object with the specified context.  The context
   /// takes ownership of the heap allocated dialect.
   void registerDialect(MLIRContext *context);
 
private:
   bool unknownOpsAllowed = false;
 
   /// Flag that specifies whether this dialect allows unregistered types, i.e.
   /// types prefixed with the dialect namespace but not registered with addType.
   /// These types are represented with OpaqueType.
   bool unknownTypesAllowed = false;
 
   /// A collection of registered dialect interfaces.
-  DenseMap<ClassID *, std::unique_ptr<DialectInterface>> registeredInterfaces;
+  DenseMap<TypeID, std::unique_ptr<DialectInterface>> registeredInterfaces;
 
   /// Registers a specific dialect creation function with the global registry.
   /// Used through the registerDialect template.
-  /// Registrations are deduplicated by dialect ClassID and only the first
+  /// Registrations are deduplicated by dialect TypeID and only the first
   /// registration will be used.
   static void
-  registerDialectAllocator(const ClassID *classId,
+  registerDialectAllocator(TypeID typeID,
                            const DialectAllocatorFunction &function);
   template <typename ConcreteDialect>
   friend void registerDialect();
 };
 /// Registers all dialects and hooks from the global registries with the
 /// specified MLIRContext.
 void registerAllDialects(MLIRContext *context);
 
 /// Utility to register a dialect. Client can register their dialect with the
 /// global registry by calling registerDialect<MyDialect>();
 template <typename ConcreteDialect> void registerDialect() {
-  Dialect::registerDialectAllocator(ClassID::getID<ConcreteDialect>(),
+  Dialect::registerDialectAllocator(TypeID::get<ConcreteDialect>(),
                                     [](MLIRContext *ctx) {
                                       // Just allocate the dialect, the context
                                       // takes ownership of it.
                                       new ConcreteDialect(ctx);
                                     });
 }
 
 /// DialectRegistration provides a global initializer that registers a Dialect

mlir/include/mlir/IR/DialectHooks.h

public:
   DialectConstantFoldHook getConstantFoldHook() { return nullptr; }
   // Returns hook to decode opaque constant tensor.
   DialectConstantDecodeHook getDecodeHook() { return nullptr; }
   // Returns hook to extract an element of an opaque constant tensor.
   DialectExtractElementHook getExtractElementHook() { return nullptr; }
 
 private:
   /// Registers a function that will set hooks in the registered dialects.
-  /// Registrations are deduplicated by dialect ClassID and only the first
+  /// Registrations are deduplicated by dialect TypeID and only the first
   /// registration will be used.
-  static void registerDialectHooksSetter(const ClassID *classId,
+  static void registerDialectHooksSetter(TypeID typeID,
                                          const DialectHooksSetter &function);
   template <typename ConcreteHooks>
   friend void registerDialectHooks(StringRef dialectName);
 };
 
-void registerDialectHooksSetter(const ClassID *classId,
+void registerDialectHooksSetter(TypeID typeID,
                                 const DialectHooksSetter &function);
 
 /// Utility to register dialect hooks. Client can register their dialect hooks
 /// with the global registry by calling
 /// registerDialectHooks<MyHooks>("dialect_namespace");
 template <typename ConcreteHooks>
 void registerDialectHooks(StringRef dialectName) {
   DialectHooks::registerDialectHooksSetter(
-      ClassID::getID<ConcreteHooks>(), [dialectName](MLIRContext *ctx) {
+      TypeID::get<ConcreteHooks>(), [dialectName](MLIRContext *ctx) {
         Dialect *dialect = ctx->getRegisteredDialect(dialectName);
         if (!dialect) {
           llvm::errs() << "error: cannot register hooks for unknown dialect '"
                        << dialectName << "'\n";
           abort();
         }
         // Set hooks.
         ConcreteHooks hooks;

mlir/include/mlir/IR/DialectInterface.h

 //===- DialectInterface.h - IR Dialect Interfaces ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_DIALECTINTERFACE_H
 #define MLIR_IR_DIALECTINTERFACE_H
 
-#include "mlir/Support/STLExtras.h"
+#include "mlir/Support/TypeID.h"
 #include "llvm/ADT/DenseSet.h"
 
 namespace mlir {
 class Dialect;
 class MLIRContext;
 class Operation;
 
 //===----------------------------------------------------------------------===//
 // DialectInterface
 //===----------------------------------------------------------------------===//
 namespace detail {
 /// The base class used for all derived interface types. This class provides
 /// utilities necessary for registration.
 template <typename ConcreteType, typename BaseT>
 class DialectInterfaceBase : public BaseT {
 public:
   using Base = DialectInterfaceBase<ConcreteType, BaseT>;
 
   /// Get a unique id for the derived interface type.
-  static ClassID *getInterfaceID() { return ClassID::getID<ConcreteType>(); }
+  static TypeID getInterfaceID() { return TypeID::get<ConcreteType>(); }
 
 protected:
   DialectInterfaceBase(Dialect *dialect) : BaseT(dialect, getInterfaceID()) {}
 };
 } // end namespace detail
 
 /// This class represents an interface overridden for a single dialect.
 class DialectInterface {
 public:
   virtual ~DialectInterface();
 
   /// The base class used for all derived interface types. This class provides
   /// utilities necessary for registration.
   template <typename ConcreteType>
   using Base = detail::DialectInterfaceBase<ConcreteType, DialectInterface>;
 
   /// Return the dialect that this interface represents.
   Dialect *getDialect() const { return dialect; }
 
   /// Return the derived interface id.
-  ClassID *getID() const { return interfaceID; }
+  TypeID getID() const { return interfaceID; }
 
 protected:
-  DialectInterface(Dialect *dialect, ClassID *id)
+  DialectInterface(Dialect *dialect, TypeID id)
       : dialect(dialect), interfaceID(id) {}
 
 private:
   /// The dialect that represents this interface.
   Dialect *dialect;
 
   /// The unique identifier for the derived interface type.
-  ClassID *interfaceID;
+  TypeID interfaceID;
 };
 
 //===----------------------------------------------------------------------===//
 // DialectInterfaceCollection
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 /// This class is the base class for a collection of instances for a specific
struct InterfaceKeyInfo : public DenseMapInfo<const DialectInterface *> {
     }
   };
 
   /// A set of registered dialect interface instances.
   using InterfaceSetT = DenseSet<const DialectInterface *, InterfaceKeyInfo>;
   using InterfaceVectorT = std::vector<const DialectInterface *>;
 
 public:
-  DialectInterfaceCollectionBase(MLIRContext *ctx, ClassID *interfaceKind);
+  DialectInterfaceCollectionBase(MLIRContext *ctx, TypeID interfaceKind);
   virtual ~DialectInterfaceCollectionBase();
 
 protected:
   /// Get the interface for the dialect of given operation, or null if one
   /// is not registered.
   const DialectInterface *getInterfaceFor(Operation *op) const;
 
   /// Get the interface for the given dialect.

mlir/include/mlir/IR/Location.h

 public:
   using Base::Base;
 
   /// Returns an instance of opaque location which contains a given pointer to
   /// an object. The corresponding MLIR location is set to UnknownLoc.
   template <typename T>
   static Location get(T underlyingLocation, MLIRContext *context) {
     return get(reinterpret_cast<uintptr_t>(underlyingLocation),
-               ClassID::getID<T>(), UnknownLoc::get(context));
+               TypeID::get<T>(), UnknownLoc::get(context));
   }
 
   /// Returns an instance of opaque location which contains a given pointer to
   /// an object and an additional MLIR location.
   template <typename T>
   static Location get(T underlyingLocation, Location fallbackLocation) {
     return get(reinterpret_cast<uintptr_t>(underlyingLocation),
-               ClassID::getID<T>(), fallbackLocation);
+               TypeID::get<T>(), fallbackLocation);
   }
 
   /// Returns a pointer to some data structure that opaque location stores.
   template <typename T> static T getUnderlyingLocation(Location location) {
     assert(isa<T>(location));
     return reinterpret_cast<T>(
         location.cast<mlir::OpaqueLoc>().getUnderlyingLocation());
   }
 
   /// Returns a pointer to some data structure that opaque location stores.
   /// Returns nullptr if provided location is not opaque location or if it
   /// contains a pointer of different type.
   template <typename T>
   static T getUnderlyingLocationOrNull(Location location) {
     return isa<T>(location)
                ? reinterpret_cast<T>(
                      location.cast<mlir::OpaqueLoc>().getUnderlyingLocation())
                : T(nullptr);
   }
 
   /// Checks whether provided location is opaque location and contains a pointer
   /// to an object of particular type.
   template <typename T> static bool isa(Location location) {
     auto opaque_loc = location.dyn_cast<OpaqueLoc>();
-    return opaque_loc && opaque_loc.getClassId() == ClassID::getID<T>();
+    return opaque_loc && opaque_loc.getClassID() == TypeID::get<T>();
   }
 
   /// Returns a pointer to the corresponding object.
   uintptr_t getUnderlyingLocation() const;
 
-  /// Returns a ClassID* that represents the underlying objects c++ type.
-  ClassID *getClassId() const;
+  /// Returns a TypeID that represents the underlying objects c++ type.
+  TypeID getClassID() const;
 
   /// Returns a fallback location.
   Location getFallbackLocation() const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool kindof(unsigned kind) {
     return kind == StandardAttributes::OpaqueLocation;
   }
 
 private:
-  static Location get(uintptr_t underlyingLocation, ClassID *classID,
+  static Location get(uintptr_t underlyingLocation, TypeID typeID,
                       Location fallbackLocation);
 };
 
 // Make Location hashable.
 inline ::llvm::hash_code hash_value(Location arg) {
   return hash_value(arg.impl);
 }
 

mlir/include/mlir/IR/OpDefinition.h

public:
   Dialect *getDialect() { return getOperation()->getDialect(); }
 
   /// Return the parent Region of this operation.
   Region *getParentRegion() { return getOperation()->getParentRegion(); }
 
   /// Return true if this "op class" can match against the specified operation.
   static bool classof(Operation *op) {
     if (auto *abstractOp = op->getAbstractOperation())
-      return ClassID::getID<ConcreteType>() == abstractOp->classID;
+      return TypeID::get<ConcreteType>() == abstractOp->typeID;
     return op->getName().getStringRef() == ConcreteType::getOperationName();
   }
 
   /// This is the hook used by the AsmParser to parse the custom form of this
   /// op from an .mlir file.  Op implementations should provide a parse method,
   /// which returns failure.  On success, they should return fill in result with
   /// the fields to use.
   static ParseResult parseAssembly(OpAsmParser &parser,
private:
   };
 
   template <typename...> struct BaseProperties {
     static AbstractOperation::OperationProperties getTraitProperties() {
       return 0;
     }
   };
 
-  /// Returns true if this operation contains the trait for the given classID.
-  static bool hasTrait(ClassID *traitID) {
-    return llvm::is_contained(llvm::makeArrayRef({ClassID::getID<Traits>()...}),
+  /// Returns true if this operation contains the trait for the given typeID.
+  static bool hasTrait(TypeID traitID) {
+    return llvm::is_contained(llvm::makeArrayRef({TypeID::get<Traits>()...}),
                               traitID);
   }
 
   /// Returns an opaque pointer to a concept instance of the interface with the
   /// given ID if one was registered to this operation.
-  static void *getRawInterface(ClassID *id) {
+  static void *getRawInterface(TypeID id) {
     return InterfaceLookup::template lookup<Traits<ConcreteType>...>(id);
   }
 
   struct InterfaceLookup {
     /// Trait to check if T provides a static 'getInterfaceID' method.
     template <typename T, typename... Args>
     using has_get_interface_id = decltype(T::getInterfaceID());
 
     /// If 'T' is the same interface as 'interfaceID' return the concept
     /// instance.
     template <typename T>
     static typename std::enable_if<is_detected<has_get_interface_id, T>::value,
                                    void *>::type
-    lookup(ClassID *interfaceID) {
+    lookup(TypeID interfaceID) {
       return (T::getInterfaceID() == interfaceID) ? &T::instance() : nullptr;
     }
 
     /// 'T' is known to not be an interface, return nullptr.
     template <typename T>
     static typename std::enable_if<!is_detected<has_get_interface_id, T>::value,
                                    void *>::type
-    lookup(ClassID *) {
+    lookup(TypeID) {
       return nullptr;
     }
 
     template <typename T, typename T2, typename... Ts>
-    static void *lookup(ClassID *interfaceID) {
+    static void *lookup(TypeID interfaceID) {
       auto *concept = lookup<T>(interfaceID);
       return concept ? concept : lookup<T2, Ts...>(interfaceID);
     }
   };
 
   /// Allow access to 'hasTrait' and 'getRawInterface'.
   friend AbstractOperation;
 };
assert((!op || impl) &&
            "instantiating an interface with an unregistered operation");
   }
 
   /// Support 'classof' by checking if the given operation defines the concrete
   /// interface.
   static bool classof(Operation *op) { return getInterfaceFor(op); }
 
   /// Define an accessor for the ID of this interface.
-  static ClassID *getInterfaceID() { return ClassID::getID<ConcreteType>(); }
+  static TypeID getInterfaceID() { return TypeID::get<ConcreteType>(); }
 
   /// This is a special trait that registers a given interface with an
   /// operation.
   template <typename ConcreteOp>
   struct Trait : public OpTrait::TraitBase<ConcreteOp, Trait> {
     /// Define an accessor for the ID of this interface.
-    static ClassID *getInterfaceID() { return ClassID::getID<ConcreteType>(); }
+    static TypeID getInterfaceID() { return TypeID::get<ConcreteType>(); }
 
     /// Provide an accessor to a static instance of the interface model for the
     /// concrete operation type.
     /// The implementation is inspired from Sean Parent's concept-based
     /// polymorphism. A key difference is that the set of classes erased is
     /// statically known, which alleviates the need for using dynamic memory
     /// allocation.
     /// We use a zero-sized templated class `Model<ConcreteOp>` to emit the

mlir/include/mlir/IR/OperationSupport.h

public:
 
   /// This is the name of the operation.
   const StringRef name;
 
   /// This is the dialect that this operation belongs to.
   Dialect &dialect;
 
   /// The unique identifier of the derived Op class.
-  ClassID *classID;
+  TypeID typeID;
 
   /// Use the specified object to parse this ops custom assembly format.
   ParseResult (&parseAssembly)(OpAsmParser &parser, OperationState &result);
 
   /// This hook implements the AsmPrinter for this operation.
   void (&printAssembly)(Operation *op, OpAsmPrinter &p);
 
   /// This hook implements the verifier for this operation.  It should emits an
public:
   /// directly.
   template <typename T> typename T::Concept *getInterface() const {
     return reinterpret_cast<typename T::Concept *>(
         getRawInterface(T::getInterfaceID()));
   }
 
   /// Returns if the operation has a particular trait.
   template <template <typename T> class Trait> bool hasTrait() const {
-    return hasRawTrait(ClassID::getID<Trait>());
+    return hasRawTrait(TypeID::get<Trait>());
   }
 
   /// Look up the specified operation in the specified MLIRContext and return a
   /// pointer to it if present.  Otherwise, return a null pointer.
   static const AbstractOperation *lookup(StringRef opName,
                                          MLIRContext *context);
 
   /// This constructor is used by Dialect objects when they register the list of
   /// operations they contain.
   template <typename T> static AbstractOperation get(Dialect &dialect) {
     return AbstractOperation(
         T::getOperationName(), dialect, T::getOperationProperties(),
-        ClassID::getID<T>(), T::parseAssembly, T::printAssembly,
+        TypeID::get<T>(), T::parseAssembly, T::printAssembly,
         T::verifyInvariants, T::foldHook, T::getCanonicalizationPatterns,
         T::getRawInterface, T::hasTrait);
   }
 
 private:
   AbstractOperation(
       StringRef name, Dialect &dialect, OperationProperties opProperties,
-      ClassID *classID,
+      TypeID typeID,
       ParseResult (&parseAssembly)(OpAsmParser &parser, OperationState &result),
       void (&printAssembly)(Operation *op, OpAsmPrinter &p),
       LogicalResult (&verifyInvariants)(Operation *op),
       LogicalResult (&foldHook)(Operation *op, ArrayRef<Attribute> operands,
                                 SmallVectorImpl<OpFoldResult> &results),
       void (&getCanonicalizationPatterns)(OwningRewritePatternList &results,
                                           MLIRContext *context),
-      void *(&getRawInterface)(ClassID *interfaceID),
-      bool (&hasTrait)(ClassID *traitID))
-      : name(name), dialect(dialect), classID(classID),
+      void *(&getRawInterface)(TypeID interfaceID),
+      bool (&hasTrait)(TypeID traitID))
+      : name(name), dialect(dialect), typeID(typeID),
         parseAssembly(parseAssembly), printAssembly(printAssembly),
         verifyInvariants(verifyInvariants), foldHook(foldHook),
         getCanonicalizationPatterns(getCanonicalizationPatterns),
         opProperties(opProperties), getRawInterface(getRawInterface),
         hasRawTrait(hasTrait) {}
 
   /// The properties of the operation.
   const OperationProperties opProperties;
 
   /// Returns a raw instance of the concept for the given interface id if it is
   /// registered to this operation, nullptr otherwise. This should not be used
   /// directly.
-  void *(&getRawInterface)(ClassID *interfaceID);
+  void *(&getRawInterface)(TypeID interfaceID);
 
   /// This hook returns if the operation contains the trait corresponding
-  /// to the given ClassID.
-  bool (&hasRawTrait)(ClassID *traitID);
+  /// to the given TypeID.
+  bool (&hasRawTrait)(TypeID traitID);
 };
 
 //===----------------------------------------------------------------------===//
 // OperationName
 //===----------------------------------------------------------------------===//
 
 class OperationName {
 public:

mlir/include/mlir/IR/StorageUniquerSupport.h

 //===- StorageUniquerSupport.h - MLIR Storage Uniquer Utilities -*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines utility classes for interfacing with StorageUniquer.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_STORAGEUNIQUERSUPPORT_H
 #define MLIR_IR_STORAGEUNIQUERSUPPORT_H
 
 #include "mlir/Support/LogicalResult.h"
-#include "mlir/Support/STLExtras.h"
 #include "mlir/Support/StorageUniquer.h"
+#include "mlir/Support/TypeID.h"
 
 namespace mlir {
 class AttributeStorage;
 class MLIRContext;
 
 namespace detail {
 /// Utility method to generate a raw default location for use when checking the
 /// construction invariants of a storage object. This is defined out-of-line to

 public:
   using BaseT::BaseT;
 
   /// Utility declarations for the concrete attribute class.
   using Base = StorageUserBase<ConcreteT, BaseT, StorageT, UniquerT>;
   using ImplType = StorageT;
 
   /// Return a unique identifier for the concrete type.
-  static ClassID *getClassID() { return ClassID::getID<ConcreteT>(); }
+  static TypeID getTypeID() { return TypeID::get<ConcreteT>(); }
 
   /// Provide a default implementation of 'classof' that invokes a 'kindof'
   /// method on the concrete type.
   template <typename T> static bool classof(T val) {
     static_assert(std::is_convertible<ConcreteT, T>::value,
                   "casting from a non-convertible type");
     return ConcreteT::kindof(val.getKind());
   }

mlir/include/mlir/IR/TypeSupport.h

 
 #ifndef MLIR_IR_TYPE_SUPPORT_H
 #define MLIR_IR_TYPE_SUPPORT_H
 
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StorageUniquerSupport.h"
 
 namespace mlir {
-struct ClassID;
 class Dialect;
 class MLIRContext;
 
 //===----------------------------------------------------------------------===//
 // TypeStorage
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 class TypeUniquer;
 } // end namespace detail
 
 /// Base storage class appearing in a Type.
 class TypeStorage : public StorageUniquer::BaseStorage {
   friend detail::TypeUniquer;
   friend StorageUniquer;
 
 protected:
   /// This constructor is used by derived classes as part of the TypeUniquer.
-  /// When using this constructor, the initializeTypeInfo function must be
+  /// When using this constructor, the initializeDialect function must be
   /// invoked afterwards for the storage to be valid.
   TypeStorage(unsigned subclassData = 0)
       : dialect(nullptr), subclassData(subclassData) {}
 
 public:
   /// Get the dialect that this type is registered to.
   Dialect &getDialect() {
     assert(dialect && "Malformed type storage object.");
return ctx->getTypeUniquer().get<typename T::ImplType>(
           storage->initializeDialect(lookupDialectForType<T>(ctx));
         },
         kind, std::forward<Args>(args)...);
   }
 
 private:
   /// Get the dialect that the type 'T' was registered with.
   template <typename T> static Dialect &lookupDialectForType(MLIRContext *ctx) {
-    return lookupDialectForType(ctx, T::getClassID());
+    return lookupDialectForType(ctx, T::getTypeID());
   }
 
   /// Get the dialect that registered the type with the provided typeid.
-  static Dialect &lookupDialectForType(MLIRContext *ctx,
-                                       const ClassID *const typeID);
+  static Dialect &lookupDialectForType(MLIRContext *ctx, TypeID typeID);
 };
 } // namespace detail
 
 } // end namespace mlir
 
 #endif

mlir/include/mlir/Interfaces/SideEffects.h

 public:
   /// This base class is used for derived effects that are non-parametric.
   template <typename DerivedEffect, typename BaseEffect = Effect>
   class Base : public BaseEffect {
   public:
     using BaseT = Base<DerivedEffect>;
 
     /// Return the unique identifier for the base effects class.
-    static ClassID *getEffectID() { return ClassID::getID<DerivedEffect>(); }
+    static TypeID getEffectID() { return TypeID::get<DerivedEffect>(); }
 
     /// 'classof' used to support llvm style cast functionality.
     static bool classof(const ::mlir::SideEffects::Effect *effect) {
       return effect->getEffectID() == BaseT::getEffectID();
     }
 
     /// Returns a unique instance for the derived effect class.
     static DerivedEffect *get() {
       return BaseEffect::template get<DerivedEffect>();
     }
     using BaseEffect::get;
 
   protected:
-    Base() : BaseEffect(BaseT::getEffectID()){};
+    Base() : BaseEffect(BaseT::getEffectID()) {}
   };
 
   /// Return the unique identifier for the base effects class.
-  ClassID *getEffectID() const { return id; }
+  TypeID getEffectID() const { return id; }
 
   /// Returns a unique instance for the given effect class.
   template <typename DerivedEffect> static DerivedEffect *get() {
     static_assert(std::is_base_of<Effect, DerivedEffect>::value,
                   "expected DerivedEffect to inherit from Effect");
 
     static DerivedEffect instance;
     return &instance;
   }
 
 protected:
-  Effect(ClassID *id) : id(id) {}
+  Effect(TypeID id) : id(id) {}
 
 private:
   /// The id of the derived effect class.
-  ClassID *id;
+  TypeID id;
 };
 
 //===----------------------------------------------------------------------===//
 // Resources
 //===----------------------------------------------------------------------===//
 
 /// This class represents a specific resource that an effect applies to. This
 /// class represents an abstract interface for a given resource.
public:
 
     /// Returns a unique instance for the given effect class.
     static DerivedResource *get() {
       static DerivedResource instance;
       return &instance;
     }
 
     /// Return the unique identifier for the base resource class.
-    static ClassID *getResourceID() {
-      return ClassID::getID<DerivedResource>();
-    }
+    static TypeID getResourceID() { return TypeID::get<DerivedResource>(); }
 
     /// 'classof' used to support llvm style cast functionality.
     static bool classof(const Resource *resource) {
       return resource->getResourceID() == BaseT::getResourceID();
     }
 
   protected:
     Base() : BaseResource(BaseT::getResourceID()){};
   };
 
   /// Return the unique identifier for the base resource class.
-  ClassID *getResourceID() const { return id; }
+  TypeID getResourceID() const { return id; }
 
   /// Return a string name of the resource.
   virtual StringRef getName() = 0;
 
 protected:
-  Resource(ClassID *id) : id(id) {}
+  Resource(TypeID id) : id(id) {}
 
 private:
   /// The id of the derived resource class.
-  ClassID *id;
+  TypeID id;
 };
 
 /// A conservative default resource kind.
 struct DefaultResource : public Resource::Base<DefaultResource> {
   StringRef getName() final { return "<Default>"; }
 };
 
 /// This class represents a specific instance of an effect. It contains the

mlir/include/mlir/Pass/AnalysisManager.h

 #include "mlir/IR/Module.h"
 #include "mlir/Pass/PassInstrumentation.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/TypeName.h"
 
 namespace mlir {
-/// A special type used by analyses to provide an address that identifies a
-/// particular analysis set or a concrete analysis type.
-using AnalysisID = ClassID;
-
 //===----------------------------------------------------------------------===//
 // 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;
+
 public:
   /// Mark all analyses as preserved.
-  void preserveAll() { preservedIDs.insert(&allAnalysesID); }
+  void preserveAll() { preservedIDs.insert(TypeID::get<AllAnalysesType>()); }
 
   /// Returns true if all analyses were marked preserved.
-  bool isAll() const { return preservedIDs.count(&allAnalysesID); }
+  bool isAll() const {
+    return preservedIDs.count(TypeID::get<AllAnalysesType>());
+  }
 
   /// Returns true if no analyses were marked preserved.
   bool isNone() const { return preservedIDs.empty(); }
 
   /// Preserve the given analyses.
   template <typename AnalysisT> void preserve() {
-    preserve(AnalysisID::getID<AnalysisT>());
+    preserve(TypeID::get<AnalysisT>());
   }
   template <typename AnalysisT, typename AnalysisT2, typename... OtherAnalysesT>
   void preserve() {
     preserve<AnalysisT>();
     preserve<AnalysisT2, OtherAnalysesT...>();
   }
-  void preserve(const AnalysisID *id) { preservedIDs.insert(id); }
+  void preserve(TypeID id) { preservedIDs.insert(id); }
 
   /// Returns if the given analysis has been marked as preserved. Note that this
   /// simply checks for the presence of a given analysis ID and should not be
   /// used as a general preservation checker.
   template <typename AnalysisT> bool isPreserved() const {
-    return isPreserved(AnalysisID::getID<AnalysisT>());
-  }
-  bool isPreserved(const AnalysisID *id) const {
-    return preservedIDs.count(id);
+    return isPreserved(TypeID::get<AnalysisT>());
   }
+  bool isPreserved(TypeID id) const { return preservedIDs.count(id); }
 
 private:
-  /// An identifier used to represent all potential analyses.
-  constexpr static AnalysisID allAnalysesID = {};
-
   /// The set of analyses that are known to be preserved.
-  SmallPtrSet<const void *, 2> preservedIDs;
+  SmallPtrSet<TypeID, 2> preservedIDs;
 };
 
 namespace analysis_impl {
 /// Trait to check if T provides a static 'isInvalidated' method.
 template <typename T, typename... Args>
 using has_is_invalidated = decltype(std::declval<T &>().isInvalidated(
     std::declval<const PreservedAnalyses &>()));
 
template <typename AnalysisT> struct AnalysisModel : public AnalysisConcept {
   /// The actual analysis object.
   AnalysisT analysis;
 };
 
 /// This class represents a cache of analyses for a single operation. All
 /// computation, caching, and invalidation of analyses takes place here.
 class AnalysisMap {
   /// A mapping between an analysis id and an existing analysis instance.
-  using ConceptMap =
-      DenseMap<const AnalysisID *, std::unique_ptr<AnalysisConcept>>;
+  using ConceptMap = DenseMap<TypeID, std::unique_ptr<AnalysisConcept>>;
 
   /// Utility to return the name of the given analysis class.
   template <typename AnalysisT> static StringRef getAnalysisName() {
     StringRef name = llvm::getTypeName<AnalysisT>();
     if (!name.consume_front("mlir::"))
       name.consume_front("(anonymous namespace)::");
     return name;
   }
 
 public:
   explicit AnalysisMap(Operation *ir) : ir(ir) {}
 
   /// Get an analysis for the current IR unit, computing it if necessary.
   template <typename AnalysisT> AnalysisT &getAnalysis(PassInstrumentor *pi) {
-    auto *id = AnalysisID::getID<AnalysisT>();
+    TypeID id = TypeID::get<AnalysisT>();
 
     typename ConceptMap::iterator it;
     bool wasInserted;
     std::tie(it, wasInserted) = analyses.try_emplace(id);
 
     // If we don't have a cached analysis for this function, compute it directly
     // and add it to the cache.
     if (wasInserted) {
       if (pi)
         pi->runBeforeAnalysis(getAnalysisName<AnalysisT>(), id, ir);
 
       it->second = std::make_unique<AnalysisModel<AnalysisT>>(ir);
 
       if (pi)
         pi->runAfterAnalysis(getAnalysisName<AnalysisT>(), id, ir);
     }
     return static_cast<AnalysisModel<AnalysisT> &>(*it->second).analysis;
   }
 
   /// Get a cached analysis instance if one exists, otherwise return null.
   template <typename AnalysisT>
   Optional<std::reference_wrapper<AnalysisT>> getCachedAnalysis() const {
-    auto res = analyses.find(AnalysisID::getID<AnalysisT>());
+    auto res = analyses.find(TypeID::get<AnalysisT>());
     if (res == analyses.end())
       return llvm::None;
     return {static_cast<AnalysisModel<AnalysisT> &>(*res->second).analysis};
   }
 
   /// Returns the operation that this analysis map represents.
   Operation *getOperation() const { return ir; }
 

mlir/include/mlir/Pass/Pass.h

struct PassExecutionState {
   AnalysisManager analysisManager;
 
   /// The set of preserved analyses for the current execution.
   detail::PreservedAnalyses preservedAnalyses;
 };
 } // namespace detail
 
 /// The abstract base pass class. This class contains information describing the
-/// derived pass object, e.g its kind and abstract PassInfo.
+/// derived pass object, e.g its kind and abstract TypeID.
 class Pass {
 public:
   virtual ~Pass() = default;
 
   /// Returns the unique identifier that corresponds to this pass.
-  const PassID *getPassID() const { return passID; }
+  TypeID getTypeID() const { return passID; }
 
   /// Returns the pass info for the specified pass class or null if unknown.
-  static const PassInfo *lookupPassInfo(const PassID *passID);
+  static const PassInfo *lookupPassInfo(TypeID passID);
   template <typename PassT> static const PassInfo *lookupPassInfo() {
-    return lookupPassInfo(PassID::getID<PassT>());
+    return lookupPassInfo(TypeID::get<PassT>());
   }
 
   /// Returns the pass info for this pass.
-  const PassInfo *lookupPassInfo() const { return lookupPassInfo(getPassID()); }
+  const PassInfo *lookupPassInfo() const { return lookupPassInfo(getTypeID()); }
 
   /// Returns the derived pass name.
   virtual StringRef getName() = 0;
 
   /// Returns the name of the operation that this pass operates on, or None if
   /// this is a generic OperationPass.
   Optional<StringRef> getOpName() const { return opName; }
 
private:
     using llvm::Statistic::getDebugType;
   };
 
   /// Returns the main statistics for this pass instance.
   ArrayRef<Statistic *> getStatistics() const { return statistics; }
   MutableArrayRef<Statistic *> getStatistics() { return statistics; }
 
 protected:
-  explicit Pass(const PassID *passID, Optional<StringRef> opName = llvm::None)
+  explicit Pass(TypeID passID, Optional<StringRef> opName = llvm::None)
       : passID(passID), opName(opName) {}
   Pass(const Pass &other) : Pass(other.passID, other.opName) {}
 
   /// Returns the current pass state.
   detail::PassExecutionState &getPassState() {
     assert(passState && "pass state was never initialized");
     return *passState;
   }
protected:
   void markAllAnalysesPreserved() {
     getPassState().preservedAnalyses.preserveAll();
   }
 
   /// Mark the provided analyses as preserved.
   template <typename... AnalysesT> void markAnalysesPreserved() {
     getPassState().preservedAnalyses.preserve<AnalysesT...>();
   }
-  void markAnalysesPreserved(const AnalysisID *id) {
+  void markAnalysesPreserved(TypeID id) {
     getPassState().preservedAnalyses.preserve(id);
   }
 
   /// Returns the analysis for the parent operation if it exists.
   template <typename AnalysisT>
   Optional<std::reference_wrapper<AnalysisT>>
   getCachedParentAnalysis(Operation *parent) {
     return getAnalysisManager().getCachedParentAnalysis<AnalysisT>(parent);
private:
   LLVM_NODISCARD
   LogicalResult run(Operation *op, AnalysisManager am);
 
   /// Out of line virtual method to ensure vtables and metadata are emitted to a
   /// single .o file.
   virtual void anchor();
 
   /// Represents a unique identifier for the pass.
-  const PassID *passID;
+  TypeID passID;
 
   /// The name of the operation that this pass operates on, or None if this is a
   /// generic OperationPass.
   Optional<StringRef> opName;
 
   /// The current execution state for the pass.
   Optional<detail::PassExecutionState> passState;
 

 ///     additional operations.
 ///
 /// Derived function passes are expected to provide the following:
 ///   - A 'void runOnOperation()' method.
 ///   - A 'StringRef getName() const' method.
 ///   - A 'std::unique_ptr<Pass> clonePass() const' method.
 template <typename OpT = void> class OperationPass : public Pass {
 protected:
-  OperationPass(const PassID *passID) : Pass(passID, OpT::getOperationName()) {}
+  OperationPass(TypeID passID) : Pass(passID, OpT::getOperationName()) {}
 
   /// Support isa/dyn_cast functionality.
   static bool classof(const Pass *pass) {
     return pass->getOpName() == OpT::getOperationName();
   }
 
   /// Return the current operation being transformed.
   OpT getOperation() { return cast<OpT>(Pass::getOperation()); }
 };
 
 /// Pass to transform an operation.
 ///
 /// Operation passes must not:
 ///   - modify any other operations within the parent region, as other threads
 ///     may be manipulating them concurrently.
 ///   - modify any state within the parent operation, this includes adding
 ///     additional operations.
 ///
 /// Derived function passes are expected to provide the following:
 ///   - A 'void runOnOperation()' method.
 ///   - A 'StringRef getName() const' method.
 ///   - A 'std::unique_ptr<Pass> clonePass() const' method.
 template <> class OperationPass<void> : public Pass {
 protected:
-  OperationPass(const PassID *passID) : Pass(passID) {}
+  OperationPass(TypeID passID) : Pass(passID) {}
 };
 
 /// A model for providing function pass specific utilities.
 ///
 /// Derived function passes are expected to provide the following:
 ///   - A 'void runOnFunction()' method.
 ///   - A 'StringRef getName() const' method.
 ///   - A 'std::unique_ptr<Pass> clonePass() const' method.

 /// This class provides a CRTP wrapper around a base pass class to define
 /// several necessary utility methods. This should only be used for passes that
 /// are not suitably represented using the declarative pass specification(i.e.
 /// tablegen backend).
 template <typename PassT, typename BaseT> class PassWrapper : public BaseT {
 public:
   /// Support isa/dyn_cast functionality for the derived pass class.
   static bool classof(const Pass *pass) {
-    return pass->getPassID() == PassID::getID<PassT>();
+    return pass->getTypeID() == TypeID::get<PassT>();
   }
 
 protected:
-  PassWrapper() : BaseT(PassID::getID<PassT>()) {}
+  PassWrapper() : BaseT(TypeID::get<PassT>()) {}
 
   /// Returns the derived pass name.
   StringRef getName() override {
     StringRef name = llvm::getTypeName<PassT>();
     if (!name.consume_front("mlir::"))
       name.consume_front("(anonymous namespace)::");
     return name;
   }

mlir/include/mlir/Pass/PassInstrumentation.h

 //===- PassInstrumentation.h ------------------------------------*- 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_PASS_PASSINSTRUMENTATION_H_
 #define MLIR_PASS_PASSINSTRUMENTATION_H_
 
 #include "mlir/Support/LLVM.h"
-#include "mlir/Support/STLExtras.h"
-#include "llvm/ADT/DenseMapInfo.h"
-#include "llvm/ADT/StringRef.h"
+#include "mlir/Support/TypeID.h"
 
 namespace mlir {
-using AnalysisID = ClassID;
 class Operation;
 class OperationName;
 class Pass;
 
 namespace detail {
 struct PassInstrumentorImpl;
 } // end namespace detail
 
public:
 
   /// A callback to run when a pass execution fails. This function takes a
   /// pointer to the pass that was being executed, as well as the current
   /// operation being operated on. Note that the operation may be in an invalid
   /// state.
   virtual void runAfterPassFailed(Pass *pass, Operation *op) {}
 
   /// A callback to run before an analysis is computed. This function takes the
-  /// name of the analysis to be computed, its AnalysisID, as well as the
+  /// name of the analysis to be computed, its TypeID, as well as the
   /// current operation being analyzed.
-  virtual void runBeforeAnalysis(StringRef name, AnalysisID *id,
-                                 Operation *op) {}
+  virtual void runBeforeAnalysis(StringRef name, TypeID id, Operation *op) {}
 
   /// A callback to run before an analysis is computed. This function takes the
-  /// name of the analysis that was computed, its AnalysisID, as well as the
+  /// name of the analysis that was computed, its TypeID, as well as the
   /// current operation being analyzed.
-  virtual void runAfterAnalysis(StringRef name, AnalysisID *id, Operation *op) {
-  }
+  virtual void runAfterAnalysis(StringRef name, TypeID id, Operation *op) {}
 };
 
 /// This class holds a collection of PassInstrumentation objects, and invokes
 /// their respective call backs.
 class PassInstrumentor {
 public:
   PassInstrumentor();
   PassInstrumentor(PassInstrumentor &&) = delete;
public:
 
   /// See PassInstrumentation::runAfterPass for details.
   void runAfterPass(Pass *pass, Operation *op);
 
   /// See PassInstrumentation::runAfterPassFailed for details.
   void runAfterPassFailed(Pass *pass, Operation *op);
 
   /// See PassInstrumentation::runBeforeAnalysis for details.
-  void runBeforeAnalysis(StringRef name, AnalysisID *id, Operation *op);
+  void runBeforeAnalysis(StringRef name, TypeID id, Operation *op);
 
   /// See PassInstrumentation::runAfterAnalysis for details.
-  void runAfterAnalysis(StringRef name, AnalysisID *id, Operation *op);
+  void runAfterAnalysis(StringRef name, TypeID id, Operation *op);
 
   /// Add the given instrumentation to the collection.
   void addInstrumentation(std::unique_ptr<PassInstrumentation> pi);
 
 private:
   std::unique_ptr<detail::PassInstrumentorImpl> impl;
 };
 

mlir/include/mlir/Pass/PassRegistry.h

 // passes.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_PASS_PASSREGISTRY_H_
 #define MLIR_PASS_PASSREGISTRY_H_
 
 #include "mlir/Pass/PassOptions.h"
+#include "mlir/Support/TypeID.h"
 #include <functional>
 
 namespace mlir {
 class OpPassManager;
 class Pass;
 
 namespace detail {
 class PassOptions;
 } // end namespace detail
 
 /// A registry function that adds passes to the given pass manager. This should
 /// also parse options and return success() if parsing succeeded.
 using PassRegistryFunction =
     std::function<LogicalResult(OpPassManager &, StringRef options)>;
 using PassAllocatorFunction = std::function<std::unique_ptr<Pass>()>;
 
-/// A special type used by transformation passes to provide an address that can
-/// act as a unique identifier during pass registration.
-using PassID = ClassID;
-
 //===----------------------------------------------------------------------===//
 // PassRegistry
 //===----------------------------------------------------------------------===//
 
 /// Structure to group information about a passes and pass pipelines (argument
 /// to invoke via mlir-opt, description, pass pipeline builder).
 class PassRegistryEntry {
 public:
PassPipelineInfo(
       : PassRegistryEntry(arg, description, builder, optHandler) {}
 };
 
 /// A structure to represent the information for a derived pass class.
 class PassInfo : public PassRegistryEntry {
 public:
   /// PassInfo constructor should not be invoked directly, instead use
   /// PassRegistration or registerPass.
-  PassInfo(StringRef arg, StringRef description, const PassID *passID,
+  PassInfo(StringRef arg, StringRef description, TypeID passID,
            const PassAllocatorFunction &allocator);
 };
 
 //===----------------------------------------------------------------------===//
 // PassRegistration
 //===----------------------------------------------------------------------===//
 
 /// Register a specific dialect pipeline registry function with the system,

mlir/include/mlir/Support/STLExtras.h

inline void interleaveComma(const Container &c, raw_ostream &os,
   interleave(c, os, each_fn, ", ");
 }
 template <typename Container, typename raw_ostream,
           typename T = detail::ValueOfRange<Container>>
 inline void interleaveComma(const Container &c, raw_ostream &os) {
   interleaveComma(c, os, [&](const T &a) { os << a; });
 }
 
-/// A special type used to provide an address for a given class that can act as
-/// a unique identifier during pass registration.
-/// 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) ClassID {
-  template <typename T> static ClassID *getID() {
-    static ClassID id;
-    return &id;
-  }
-  template <template <typename T> class Trait> static ClassID *getID() {
-    static ClassID id;
-    return &id;
-  }
-};
-
 /// Utilities for detecting if a given trait holds for some set of arguments
 /// 'Args'. For example, the given trait could be used to detect if a given type
 /// has a copy assignment operator:
 ///   template<class T>
 ///   using has_copy_assign_t = decltype(std::declval<T&>()
 ///                                                 = std::declval<const T&>());
 ///   bool fooHasCopyAssign = is_detected<has_copy_assign_t, FooClass>::value;
 namespace detail {

mlir/include/mlir/Support/TypeID.h

+//===- TypeID.h - TypeID RTTI class -----------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains a definition of the TypeID class. This provides a non
+// RTTI mechanism for producing unique type IDs in LLVM.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_SUPPORT_TYPEID_H
+#define MLIR_SUPPORT_TYPEID_H
+
+#include "mlir/Support/LLVM.h"
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/Support/PointerLikeTypeTraits.h"
+#include "llvm/Support/TypeName.h"
+
+namespace mlir {
+
+/// This class represents a unique identifier for a specific C++ type.
+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 {
+    // If we are compiling for a windows platform we can't rely on pointer
+    // comparison of static variables due to the inability to properly export
+    // inline template symbols for DLLs. To give a unique type ID in these
+    // situations we fallback to using the string name of the type.
+#if defined(__MINGW32__) || defined(__CYGWIN__) || defined(_WIN32)
+    Storage(StringRef typeName)
+        : typeName(typeName), typeHash(llvm::hash_value(typeName)) {}
+
+    /// This struct is a utility helper that allows for getting a concrete type
+    /// for a template-template.
+    template <template <typename T> class Trait> struct TypeWrapper {};
+
+    /// Construct an instance of the storage for the given type.
+    template <typename T> static const Storage *construct() {
+      static Storage storage(llvm::getTypeName<T>());
+      return &storage;
+    }
+    template <template <typename T> class Trait>
+    static const Storage *construct() {
+      // Use a wrapper class to allow for getting a concrete type for the
+      // template-template.
+      static Storage storage(llvm::getTypeName<TypeWrapper<Trait>>());
+      return &storage;
+    }
+
+    /// Compare two storage instances for equality.
+    static bool compare(const Storage *lhs, const Storage *rhs) {
+      if (lhs == rhs)
+        return true;
+      return lhs->typeHash == rhs->typeHash && lhs->typeName == rhs->typeName;
+    }
+
+    /// Get a hash value for the given storage instance.
+    static llvm::hash_code hash_value(const Storage *storage) {
+      return storage->typeHash;
+    }
+
+    /// A string representation for the name of the type. This is used for
+    /// hashing and a fallback for comparison.
+    StringRef typeName;
+
+    /// A cached hash of the type name.
+    llvm::hash_code typeHash;
+
+#else
+    /// Otherwise, we just need to make sure that we set the visibility of the
+    /// construction functions properly. This allows for TypeID to have the
+    /// same characteristics and performance as a uintptr_t identifier.
+
+    /// Construct an instance of the storage for the given type.
+    template <typename T>
+    LLVM_EXTERNAL_VISIBILITY static const Storage *construct() {
+      static Storage storage;
+      return &storage;
+    }
+    template <template <typename T> class Trait>
+    LLVM_EXTERNAL_VISIBILITY static const Storage *construct() {
+      static Storage storage;
+      return &storage;
+    }
+
+    /// Compare two storage instances for equality.
+    static bool compare(const Storage *lhs, const Storage *rhs) {
+      return lhs == rhs;
+    }
+
+    /// Get a hash value for the given storage instance.
+    static llvm::hash_code hash_value(const Storage *storage) {
+      return llvm::hash_value(storage);
+    }
+#endif
+  };
+
+public:
+  TypeID() : TypeID(get<void>()) {}
+  TypeID(const TypeID &) = default;
+
+  /// Comparison operations.
+  bool operator==(const TypeID &other) const {
+    return Storage::compare(storage, other.storage);
+  }
+  bool operator!=(const TypeID &other) const { return !(*this == other); }
+
+  /// Construct a type info object for the given type T.
+  template <typename T> static TypeID get() {
+    return TypeID(Storage::construct<T>());
+  }
+  template <template <typename> class Trait> static TypeID get() {
+    return TypeID(Storage::construct<Trait>());
+  }
+
+  /// Methods for supporting PointerLikeTypeTraits.
+  const void *getAsOpaquePointer() const {
+    return static_cast<const void *>(storage);
+  }
+  static TypeID getFromOpaquePointer(const void *pointer) {
+    return TypeID(reinterpret_cast<const Storage *>(pointer));
+  }
+
+  /// Enable hashing TypeID.
+  friend ::llvm::hash_code hash_value(TypeID info);
+
+private:
+  TypeID(const Storage *storage) : storage(storage) {}
+
+  /// The storage of this type info object.
+  const Storage *storage;
+};
+
+/// Enable hashing TypeID.
+inline ::llvm::hash_code hash_value(TypeID info) {
+  return TypeID::Storage::hash_value(info.storage);
+}
+
+} // end namespace mlir
+
+namespace llvm {
+template <> struct DenseMapInfo<mlir::TypeID> {
+  /// Dummy types used to represent Tombstone and Empty keys for hashing.
+  struct TombstoneKeyType;
+  struct EmptyKeyType;
+
+  static mlir::TypeID getEmptyKey() {
+    return mlir::TypeID::get<EmptyKeyType>();
+  }
+  static mlir::TypeID getTombstoneKey() {
+    return mlir::TypeID::get<TombstoneKeyType>();
+  }
+  static unsigned getHashValue(mlir::TypeID val) {
+    return mlir::hash_value(val);
+  }
+  static bool isEqual(mlir::TypeID lhs, mlir::TypeID rhs) { return lhs == rhs; }
+};
+
+/// We align TypeID::Storage by 8, so allow LLVM to steal the low bits.
+template <> struct PointerLikeTypeTraits<mlir::TypeID> {
+  static inline void *getAsVoidPointer(mlir::TypeID info) {
+    return const_cast<void *>(info.getAsOpaquePointer());
+  }
+  static inline mlir::TypeID getFromVoidPointer(void *ptr) {
+    return mlir::TypeID::getFromOpaquePointer(ptr);
+  }
+  static constexpr int NumLowBitsAvailable = 3;
+};
+
+} // end namespace llvm
+
+#endif // MLIR_SUPPORT_TYPEID_H

mlir/lib/Dialect/Affine/Transforms/AffineLoopInvariantCodeMotion.cpp

 
 namespace {
 
 /// Loop invariant code motion (LICM) pass.
 /// TODO(asabne) : The pass is missing zero-trip tests.
 /// TODO(asabne) : Check for the presence of side effects before hoisting.
 /// TODO: This code should be removed once the new LICM pass can handle its
 ///       uses.
-struct LoopInvariantCodeMotion
-    : public AffineLoopInvariantCodeMotionBase<LoopInvariantCodeMotion> {
+struct AffineLoopInvariantCodeMotion
+    : public AffineLoopInvariantCodeMotionBase<AffineLoopInvariantCodeMotion> {
   void runOnFunction() override;
   void runOnAffineForOp(AffineForOp forOp);
 };
 } // end anonymous namespace
 
 static bool
 checkInvarianceOfNestedIfOps(Operation *op, Value indVar,
                              SmallPtrSetImpl<Operation *> &definedOps,
bool checkInvarianceOfNestedIfOps(Operation *op, Value indVar,
   if (!areAllOpsInTheBlockListInvariant(ifOp.elseRegion(), indVar, definedOps,
                                         opsToHoist)) {
     return false;
   }
 
   return true;
 }
 
-void LoopInvariantCodeMotion::runOnAffineForOp(AffineForOp forOp) {
+void AffineLoopInvariantCodeMotion::runOnAffineForOp(AffineForOp forOp) {
   auto *loopBody = forOp.getBody();
   auto indVar = forOp.getInductionVar();
 
   SmallPtrSet<Operation *, 8> definedOps;
   // This is the place where hoisted instructions would reside.
   OpBuilder b(forOp.getOperation());
 
   SmallPtrSet<Operation *, 8> opsToHoist;
void AffineLoopInvariantCodeMotion::runOnAffineForOp(AffineForOp forOp) {
   // right before the for loop.
   for (auto *op : opsToMove) {
     op->moveBefore(forOp);
   }
 
   LLVM_DEBUG(forOp.getOperation()->print(llvm::dbgs() << "Modified loop\n"));
 }
 
-void LoopInvariantCodeMotion::runOnFunction() {
+void AffineLoopInvariantCodeMotion::runOnFunction() {
   // Walk through all loops in a function in innermost-loop-first order.  This
   // way, we first LICM from the inner loop, and place the ops in
   // the outer loop, which in turn can be further LICM'ed.
   getFunction().walk([&](AffineForOp op) {
     LLVM_DEBUG(op.getOperation()->print(llvm::dbgs() << "\nOriginal loop\n"));
     runOnAffineForOp(op);
   });
 }
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::createAffineLoopInvariantCodeMotionPass() {
-  return std::make_unique<LoopInvariantCodeMotion>();
+  return std::make_unique<AffineLoopInvariantCodeMotion>();
 }

mlir/lib/IR/Dialect.cpp

 
 DialectAsmParser::~DialectAsmParser() {}
 
 //===----------------------------------------------------------------------===//
 // Dialect Registration
 //===----------------------------------------------------------------------===//
 
 /// Registry for all dialect allocation functions.
-static llvm::ManagedStatic<
-    llvm::MapVector<const ClassID *, DialectAllocatorFunction>>
+static llvm::ManagedStatic<llvm::MapVector<TypeID, DialectAllocatorFunction>>
     dialectRegistry;
 
 /// Registry for functions that set dialect hooks.
-static llvm::ManagedStatic<llvm::MapVector<const ClassID *, DialectHooksSetter>>
+static llvm::ManagedStatic<llvm::MapVector<TypeID, DialectHooksSetter>>
     dialectHooksRegistry;
 
 void Dialect::registerDialectAllocator(
-    const ClassID *classId, const DialectAllocatorFunction &function) {
+    TypeID typeID, const DialectAllocatorFunction &function) {
   assert(function &&
          "Attempting to register an empty dialect initialize function");
-  dialectRegistry->insert({classId, function});
+  dialectRegistry->insert({typeID, function});
 }
 
 /// Registers a function to set specific hooks for a specific dialect, typically
 /// used through the DialectHooksRegistration template.
 void DialectHooks::registerDialectHooksSetter(
-    const ClassID *classId, const DialectHooksSetter &function) {
+    TypeID typeID, const DialectHooksSetter &function) {
   assert(
       function &&
       "Attempting to register an empty dialect hooks initialization function");
 
-  dialectHooksRegistry->insert({classId, function});
+  dialectHooksRegistry->insert({typeID, function});
 }
 
 /// Registers all dialects and hooks from the global registries with the
 /// specified MLIRContext.
 void mlir::registerAllDialects(MLIRContext *context) {
   for (const auto &it : *dialectRegistry)
     it.second(context);
-  for (const auto &it : *dialectHooksRegistry) {
+  for (const auto &it : *dialectHooksRegistry)
     it.second(context);
-  }
-}
 
 //===----------------------------------------------------------------------===//
 // Dialect
 //===----------------------------------------------------------------------===//
 
 Dialect::Dialect(StringRef name, MLIRContext *context)
     : name(name), context(context) {
   assert(isValidNamespace(name) && "invalid dialect namespace");

 
 //===----------------------------------------------------------------------===//
 // Dialect Interface
 //===----------------------------------------------------------------------===//
 
 DialectInterface::~DialectInterface() {}
 
 DialectInterfaceCollectionBase::DialectInterfaceCollectionBase(
-    MLIRContext *ctx, ClassID *interfaceKind) {
+    MLIRContext *ctx, TypeID interfaceKind) {
   for (auto *dialect : ctx->getRegisteredDialects()) {
     if (auto *interface = dialect->getRegisteredInterface(interfaceKind)) {
       interfaces.insert(interface);
       orderedInterfaces.push_back(interface);
     }
   }
 }
 
 DialectInterfaceCollectionBase::~DialectInterfaceCollectionBase() {}
 
 /// Get the interface for the dialect of given operation, or null if one
 /// is not registered.
 const DialectInterface *
 DialectInterfaceCollectionBase::getInterfaceFor(Operation *op) const {
   return getInterfaceFor(op->getDialect());
 }

mlir/lib/IR/Location.cpp

 
 /// Return the child location.
 Location NameLoc::getChildLoc() const { return getImpl()->child; }
 
 //===----------------------------------------------------------------------===//
 // OpaqueLoc
 //===----------------------------------------------------------------------===//
 
-Location OpaqueLoc::get(uintptr_t underlyingLocation, ClassID *classID,
+Location OpaqueLoc::get(uintptr_t underlyingLocation, TypeID typeID,
                         Location fallbackLocation) {
   return Base::get(fallbackLocation->getContext(),
                    StandardAttributes::OpaqueLocation, underlyingLocation,
-                   classID, fallbackLocation);
+                   typeID, fallbackLocation);
 }
 
 uintptr_t OpaqueLoc::getUnderlyingLocation() const {
   return Base::getImpl()->underlyingLocation;
 }
 
-ClassID *OpaqueLoc::getClassId() const { return getImpl()->classId; }
+TypeID OpaqueLoc::getClassID() const { return getImpl()->typeID; }
 
 Location OpaqueLoc::getFallbackLocation() const {
   return Base::getImpl()->fallbackLocation;
 }

mlir/lib/IR/LocationDetail.h

return new (allocator.allocate<NameLocationStorage>())
         NameLocationStorage(key.first, key.second);
   }
 
   Identifier name;
   Location child;
 };
 
 struct OpaqueLocationStorage : public AttributeStorage {
-  OpaqueLocationStorage(uintptr_t underlyingLocation, ClassID *classId,
+  OpaqueLocationStorage(uintptr_t underlyingLocation, TypeID typeID,
                         Location fallbackLocation)
-      : underlyingLocation(underlyingLocation), classId(classId),
+      : underlyingLocation(underlyingLocation), typeID(typeID),
         fallbackLocation(fallbackLocation) {}
 
   /// The hash key used for uniquing.
-  using KeyTy = std::tuple<uintptr_t, ClassID *, Location>;
+  using KeyTy = std::tuple<uintptr_t, TypeID, Location>;
   bool operator==(const KeyTy &key) const {
-    return key == KeyTy(underlyingLocation, classId, fallbackLocation);
+    return key == KeyTy(underlyingLocation, typeID, fallbackLocation);
   }
 
   /// Construct a new storage instance.
   static OpaqueLocationStorage *construct(AttributeStorageAllocator &allocator,
                                           const KeyTy &key) {
     return new (allocator.allocate<OpaqueLocationStorage>())
         OpaqueLocationStorage(std::get<0>(key), std::get<1>(key),
                               std::get<2>(key));
   }
 
   /// Pointer to the corresponding object.
   uintptr_t underlyingLocation;
 
   /// A unique pointer for each type of underlyingLocation.
-  ClassID *classId;
+  TypeID typeID;
 
   /// An additional location that can be used if the external one is not
   /// suitable.
   Location fallbackLocation;
 };
 
 } // end namespace detail
 } // end namespace mlir
 
 #endif // MLIR_IR_LOCATIONDETAIL_H_

mlir/lib/IR/MLIRContext.cpp

public:
   /// This is a list of dialects that are created referring to this context.
   /// The MLIRContext owns the objects.
   std::vector<std::unique_ptr<Dialect>> dialects;
 
   /// This is a mapping from operation name to AbstractOperation for registered
   /// operations.
   llvm::StringMap<AbstractOperation> registeredOperations;
 
-  /// This is a mapping from class identifier to Dialect for registered
-  /// attributes and types.
-  DenseMap<const ClassID *, Dialect *> registeredDialectSymbols;
+  /// This is a mapping from type id to Dialect for registered attributes and
+  /// types.
+  DenseMap<TypeID, Dialect *> registeredDialectSymbols;
 
   /// These are identifiers uniqued into this MLIRContext.
   llvm::StringMap<char, llvm::BumpPtrAllocator &> identifiers;
 
   //===--------------------------------------------------------------------===//
   // Affine uniquing
   //===--------------------------------------------------------------------===//
 
void Dialect::addOperation(AbstractOperation opInfo) {
   if (!impl.registeredOperations.insert({opInfo.name, opInfo}).second) {
     llvm::errs() << "error: operation named '" << opInfo.name
                  << "' is already registered.\n";
     abort();
   }
 }
 
 /// Register a dialect-specific symbol(e.g. type) with the current context.
-void Dialect::addSymbol(const ClassID *const classID) {
+void Dialect::addSymbol(TypeID typeID) {
   auto &impl = context->getImpl();
 
   // Lock access to the context registry.
   llvm::sys::SmartScopedWriter<true> registryLock(impl.contextMutex);
-  if (!impl.registeredDialectSymbols.insert({classID, this}).second) {
+  if (!impl.registeredDialectSymbols.insert({typeID, this}).second) {
     llvm::errs() << "error: dialect symbol already registered.\n";
     abort();
   }
 }
 
 /// Look up the specified operation in the operation set and return a pointer
 /// to it if present.  Otherwise, return a null pointer.
 const AbstractOperation *AbstractOperation::lookup(StringRef opName,
Identifier Identifier::get(StringRef str, MLIRContext *context) {
   auto it = impl.identifiers.insert({str, char()}).first;
   return Identifier(it->getKeyData());
 }
 
 //===----------------------------------------------------------------------===//
 // Type uniquing
 //===----------------------------------------------------------------------===//
 
-static Dialect &lookupDialectForSymbol(MLIRContext *ctx,
-                                       const ClassID *const classID) {
+static Dialect &lookupDialectForSymbol(MLIRContext *ctx, TypeID typeID) {
   auto &impl = ctx->getImpl();
-  auto it = impl.registeredDialectSymbols.find(classID);
+  auto it = impl.registeredDialectSymbols.find(typeID);
   assert(it != impl.registeredDialectSymbols.end() &&
          "symbol is not registered.");
   return *it->second;
 }
 
 /// Returns the storage uniquer used for constructing type storage instances.
 /// This should not be used directly.
 StorageUniquer &MLIRContext::getTypeUniquer() { return getImpl().typeUniquer; }
 
 /// Get the dialect that registered the type with the provided typeid.
-Dialect &TypeUniquer::lookupDialectForType(MLIRContext *ctx,
-                                           const ClassID *const typeID) {
+Dialect &TypeUniquer::lookupDialectForType(MLIRContext *ctx, TypeID typeID) {
   return lookupDialectForSymbol(ctx, typeID);
 }
 
 FloatType FloatType::get(StandardTypes::Kind kind, MLIRContext *context) {
   assert(kindof(kind) && "Not a FP kind.");
   switch (kind) {
   case StandardTypes::BF16:
     return context->getImpl().bf16Ty;

 /// Returns the storage uniquer used for constructing attribute storage
 /// instances. This should not be used directly.
 StorageUniquer &MLIRContext::getAttributeUniquer() {
   return getImpl().attributeUniquer;
 }
 
 /// Returns a functor used to initialize new attribute storage instances.
 std::function<void(AttributeStorage *)>
-AttributeUniquer::getInitFn(MLIRContext *ctx, const ClassID *const attrID) {
+AttributeUniquer::getInitFn(MLIRContext *ctx, TypeID attrID) {
   return [ctx, attrID](AttributeStorage *storage) {
     storage->initializeDialect(lookupDialectForSymbol(ctx, attrID));
 
     // If the attribute did not provide a type, then default to NoneType.
     if (!storage->getType())
       storage->setType(NoneType::get(ctx));
   };
 }

mlir/lib/Pass/Pass.cpp

 /// See PassInstrumentation::runAfterPassFailed for details.
 void PassInstrumentor::runAfterPassFailed(Pass *pass, Operation *op) {
   llvm::sys::SmartScopedLock<true> instrumentationLock(impl->mutex);
   for (auto &instr : llvm::reverse(impl->instrumentations))
     instr->runAfterPassFailed(pass, op);
 }
 
 /// See PassInstrumentation::runBeforeAnalysis for details.
-void PassInstrumentor::runBeforeAnalysis(StringRef name, AnalysisID *id,
+void PassInstrumentor::runBeforeAnalysis(StringRef name, TypeID id,
                                          Operation *op) {
   llvm::sys::SmartScopedLock<true> instrumentationLock(impl->mutex);
   for (auto &instr : impl->instrumentations)
     instr->runBeforeAnalysis(name, id, op);
 }
 
 /// See PassInstrumentation::runAfterAnalysis for details.
-void PassInstrumentor::runAfterAnalysis(StringRef name, AnalysisID *id,
+void PassInstrumentor::runAfterAnalysis(StringRef name, TypeID id,
                                         Operation *op) {
   llvm::sys::SmartScopedLock<true> instrumentationLock(impl->mutex);
   for (auto &instr : llvm::reverse(impl->instrumentations))
     instr->runAfterAnalysis(name, id, op);
 }
 
 /// Add the given instrumentation to the collection.
 void PassInstrumentor::addInstrumentation(
     std::unique_ptr<PassInstrumentation> pi) {
   llvm::sys::SmartScopedLock<true> instrumentationLock(impl->mutex);
   impl->instrumentations.emplace_back(std::move(pi));
 }
-
-constexpr AnalysisID mlir::detail::PreservedAnalyses::allAnalysesID;

mlir/lib/Pass/PassRegistry.cpp

 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 
 using namespace mlir;
 using namespace detail;
 
 /// Static mapping of all of the registered passes.
-static llvm::ManagedStatic<DenseMap<const PassID *, PassInfo>> passRegistry;
+static llvm::ManagedStatic<DenseMap<TypeID, PassInfo>> passRegistry;
 
 /// Static mapping of all of the registered pass pipelines.
 static llvm::ManagedStatic<llvm::StringMap<PassPipelineInfo>>
     passPipelineRegistry;
 
 /// Utility to create a default registry function from a pass instance.
 static PassRegistryFunction
 buildDefaultRegistryFn(const PassAllocatorFunction &allocator) {
void mlir::registerPassPipeline(
   assert(inserted && "Pass pipeline registered multiple times");
   (void)inserted;
 }
 
 //===----------------------------------------------------------------------===//
 // PassInfo
 //===----------------------------------------------------------------------===//
 
-PassInfo::PassInfo(StringRef arg, StringRef description, const PassID *passID,
+PassInfo::PassInfo(StringRef arg, StringRef description, TypeID passID,
                    const PassAllocatorFunction &allocator)
     : PassRegistryEntry(
           arg, description, buildDefaultRegistryFn(allocator),
           // Use a temporary pass to provide an options instance.
           [=](function_ref<void(const PassOptions &)> optHandler) {
             optHandler(allocator()->passOptions);
           }) {}
 
 void mlir::registerPass(StringRef arg, StringRef description,
                         const PassAllocatorFunction &function) {
   // TODO: We should use the 'arg' as the lookup key instead of the pass id.
-  const PassID *passID = function()->getPassID();
+  TypeID passID = function()->getTypeID();
   PassInfo passInfo(arg, description, passID, function);
   bool inserted = passRegistry->try_emplace(passID, passInfo).second;
   assert(inserted && "Pass registered multiple times");
   (void)inserted;
 }
 
 /// Returns the pass info for the specified pass class or null if unknown.
-const PassInfo *mlir::Pass::lookupPassInfo(const PassID *passID) {
+const PassInfo *mlir::Pass::lookupPassInfo(TypeID passID) {
   auto it = passRegistry->find(passID);
   if (it == passRegistry->end())
     return nullptr;
   return &it->getSecond();
 }
 
 //===----------------------------------------------------------------------===//
 // PassOptions

mlir/lib/Pass/PassTiming.cpp

void runBeforePipeline(const OperationName &name,
                          const PipelineParentInfo &parentInfo) override;
   void runAfterPipeline(const OperationName &name,
                         const PipelineParentInfo &parentInfo) override;
   void runBeforePass(Pass *pass, Operation *) override { startPassTimer(pass); }
   void runAfterPass(Pass *pass, Operation *) override;
   void runAfterPassFailed(Pass *pass, Operation *op) override {
     runAfterPass(pass, op);
   }
-  void runBeforeAnalysis(StringRef name, AnalysisID *id, Operation *) override {
+  void runBeforeAnalysis(StringRef name, TypeID id, Operation *) override {
     startAnalysisTimer(name, id);
   }
-  void runAfterAnalysis(StringRef, AnalysisID *, Operation *) override;
+  void runAfterAnalysis(StringRef, TypeID, Operation *) override;
 
   /// Print and clear the timing results.
   void print();
 
   /// Start a new timer for the given pass.
   void startPassTimer(Pass *pass);
 
   /// Start a new timer for the given analysis.
-  void startAnalysisTimer(StringRef name, AnalysisID *id);
+  void startAnalysisTimer(StringRef name, TypeID id);
 
   /// Pop the last active timer for the current thread.
   Timer *popLastActiveTimer() {
     auto tid = llvm::get_threadid();
     auto &activeTimers = activeThreadTimers[tid];
     assert(!activeTimers.empty() && "expected active timer");
     return activeTimers.pop_back_val();
   }
void PassTiming::startPassTimer(Pass *pass) {
 
   // We don't actually want to time the adaptor passes, they gather their total
   // from their held passes.
   if (!isAdaptorPass(pass))
     timer->start();
 }
 
 /// Start a new timer for the given analysis.
-void PassTiming::startAnalysisTimer(StringRef name, AnalysisID *id) {
-  Timer *timer = getTimer(id, TimerKind::PassOrAnalysis,
+void PassTiming::startAnalysisTimer(StringRef name, TypeID id) {
+  Timer *timer = getTimer(id.getAsOpaquePointer(), TimerKind::PassOrAnalysis,
                           [name] { return "(A) " + name.str(); });
   timer->start();
 }
 
 /// Stop a pass timer.
 void PassTiming::runAfterPass(Pass *pass, Operation *) {
   Timer *timer = popLastActiveTimer();
 
void PassTiming::runAfterPass(Pass *pass, Operation *) {
 
   // Adaptor passes aren't timed directly, so we don't need to stop their
   // timers.
   if (!isAdaptorPass(pass))
     timer->stop();
 }
 
 /// Stop a timer.
-void PassTiming::runAfterAnalysis(StringRef, AnalysisID *, Operation *) {
+void PassTiming::runAfterAnalysis(StringRef, TypeID, Operation *) {
   popLastActiveTimer()->stop();
 }
 
 /// Utility to print the timer heading information.
 static void printTimerHeader(raw_ostream &os, TimeRecord total) {
   os << "===" << std::string(73, '-') << "===\n";
   // Figure out how many spaces to description name.
   unsigned padding = (80 - kPassTimingDescription.size()) / 2;

mlir/tools/mlir-tblgen/PassGen.cpp

 const char *const passDeclBegin = R"(
 //===----------------------------------------------------------------------===//
 // {0}
 //===----------------------------------------------------------------------===//
 
 template <typename DerivedT>
 class {0}Base : public {1} {
 public:
-  {0}Base() : {1}(PassID::getID<DerivedT>()) {{}
-  {0}Base(const {0}Base &) : {1}(PassID::getID<DerivedT>()) {{}
+  {0}Base() : {1}(::mlir::TypeID::get<DerivedT>()) {{}
+  {0}Base(const {0}Base &) : {1}(::mlir::TypeID::get<DerivedT>()) {{}
 
   /// Returns the command-line argument attached to this pass.
   static llvm::StringRef getPassArgument() { return "{2}"; }
 
   /// Returns the derived pass name.
   llvm::StringRef getName() override { return "{0}"; }
 
   /// Support isa/dyn_cast functionality for the derived pass class.
   static bool classof(const ::mlir::Pass *pass) {{
-    return pass->getPassID() == ::mlir::PassID::getID<DerivedT>();
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
   }
 
   /// A clone method to create a copy of this pass.
   std::unique_ptr<Pass> clonePass() const override {{
     return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
   }
 
 protected: