[mlir] Remove the need to define `kindof` on attribute and type classes.

[rriddle]

Summary

This revision refactors the default definition of the attribute and type classof methods to use the TypeID of the concrete class instead of invoking the kindof method. The TypeID is already used as part of uniquing, and this allows for removing the need for users to define any of the type casting utilities themselves.

Depends On D85348

[rriddle]

Rebase

[rriddle]

Rebase

[ftynse]

Cool, thanks! I have just run into the problem of having to define kindof when implementing LLVM types, this new approach is much cleaner.

[mehdi_amini]

Thanks!

[rriddle]

Rebase

flang/include/flang/Optimizer/Dialect/FIRAttr.h

public:
   using Base::Base;
   using ValueType = mlir::Type;
 
   static constexpr llvm::StringRef getAttrName() { return "instance"; }
   static ExactTypeAttr get(mlir::Type value);
 
   mlir::Type getType() const;
 
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
   static constexpr unsigned getId() { return AttributeKind::FIR_EXACTTYPE; }
 };
 
 class SubclassAttr
     : public mlir::Attribute::AttrBase<SubclassAttr, mlir::Attribute,
                                        detail::TypeAttributeStorage> {
 public:
   using Base::Base;
   using ValueType = mlir::Type;
 
   static constexpr llvm::StringRef getAttrName() { return "subsumed"; }
   static SubclassAttr get(mlir::Type value);
 
   mlir::Type getType() const;
 
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
   static constexpr unsigned getId() { return AttributeKind::FIR_SUBCLASS; }
 };
 
 // Attributes for building SELECT CASE multiway branches
 
 /// A closed interval (including the bound values) is an interval with both an
 /// upper and lower bound as given as ssa-values.
 /// A case selector of `CASE (n:m)` corresponds to any value from `n` to `m` and
 /// is encoded as `#fir.interval, %n, %m`.
 class ClosedIntervalAttr
     : public mlir::Attribute::AttrBase<ClosedIntervalAttr, mlir::Attribute,
                                        mlir::AttributeStorage> {
 public:
   using Base::Base;
 
   static constexpr llvm::StringRef getAttrName() { return "interval"; }
   static ClosedIntervalAttr get(mlir::MLIRContext *ctxt);
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
   static constexpr unsigned getId() {
     return AttributeKind::FIR_CLOSEDCLOSED_INTERVAL;
   }
 };
 
 /// An upper bound is an open interval (including the bound value) as given as
 /// an ssa-value.
 /// A case selector of `CASE (:m)` corresponds to any value up to and including
 /// `m` and is encoded as `#fir.upper, %m`.
 class UpperBoundAttr
     : public mlir::Attribute::AttrBase<UpperBoundAttr, mlir::Attribute,
                                        mlir::AttributeStorage> {
 public:
   using Base::Base;
 
   static constexpr llvm::StringRef getAttrName() { return "upper"; }
   static UpperBoundAttr get(mlir::MLIRContext *ctxt);
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
   static constexpr unsigned getId() {
     return AttributeKind::FIR_OPENCLOSED_INTERVAL;
   }
 };
 
 /// A lower bound is an open interval (including the bound value) as given as
 /// an ssa-value.
 /// A case selector of `CASE (n:)` corresponds to any value down to and
 /// including `n` and is encoded as `#fir.lower, %n`.
 class LowerBoundAttr
     : public mlir::Attribute::AttrBase<LowerBoundAttr, mlir::Attribute,
                                        mlir::AttributeStorage> {
 public:
   using Base::Base;
 
   static constexpr llvm::StringRef getAttrName() { return "lower"; }
   static LowerBoundAttr get(mlir::MLIRContext *ctxt);
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
   static constexpr unsigned getId() {
     return AttributeKind::FIR_CLOSEDOPEN_INTERVAL;
   }
 };
 
 /// A pointer interval is a closed interval as given as an ssa-value. The
 /// interval contains exactly one value.
 /// A case selector of `CASE (p)` corresponds to exactly the value `p` and is
 /// encoded as `#fir.point, %p`.
 class PointIntervalAttr
     : public mlir::Attribute::AttrBase<PointIntervalAttr, mlir::Attribute,
                                        mlir::AttributeStorage> {
 public:
   using Base::Base;
 
   static constexpr llvm::StringRef getAttrName() { return "point"; }
   static PointIntervalAttr get(mlir::MLIRContext *ctxt);
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
   static constexpr unsigned getId() { return AttributeKind::FIR_POINT; }
 };
 
 /// A real attribute is used to workaround MLIR's default parsing of a real
 /// constant.
 /// `#fir.real<10, 3.14>` is used to introduce a real constant of value `3.14`
 /// with a kind of `10`.
 class RealAttr
     : public mlir::Attribute::AttrBase<RealAttr, mlir::Attribute,
                                        detail::RealAttributeStorage> {
 public:
   using Base::Base;
   using ValueType = std::pair<int, llvm::APFloat>;
 
   static constexpr llvm::StringRef getAttrName() { return "real"; }
   static RealAttr get(mlir::MLIRContext *ctxt, const ValueType &key);
 
   int getFKind() const;
   llvm::APFloat getValue() const;
 
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
   static constexpr unsigned getId() { return AttributeKind::FIR_REAL_ATTR; }
 };
 
 mlir::Attribute parseFirAttribute(FIROpsDialect *dialect,
                                   mlir::DialectAsmParser &parser,
                                   mlir::Type type);
 
 void printFirAttribute(FIROpsDialect *dialect, mlir::Attribute attr,
                        mlir::DialectAsmPrinter &p);
 
 } // namespace fir
 
 #endif // OPTIMIZER_DIALECT_FIRATTR_H

flang/include/flang/Optimizer/Dialect/FIRType.h

 
 /// Extract the `Type` pointed to from a FIR memory reference type. If `t` is
 /// not a memory reference type, then returns a null `Type`.
 mlir::Type dyn_cast_ptrEleTy(mlir::Type t);
 
 /// Boilerplate mixin template
 template <typename A, unsigned Id>
 struct IntrinsicTypeMixin {
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
   static constexpr unsigned getId() { return Id; }
 };
 
 // Intrinsic types
 
 /// Model of the Fortran CHARACTER intrinsic type, including the KIND type
 /// parameter. The model does not include a LEN type parameter. A CharacterType
 /// is thus the type of a single character value.

 /// describe an entity being passed from a calling context. This information
 /// might include (but is not limited to) whether the entity is an array, its
 /// size, or what type it has.
 class BoxType
     : public mlir::Type::TypeBase<BoxType, mlir::Type, detail::BoxTypeStorage> {
 public:
   using Base::Base;
   static BoxType get(mlir::Type eleTy, mlir::AffineMapAttr map = {});
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_BOX; }
   mlir::Type getEleTy() const;
   mlir::AffineMapAttr getLayoutMap() const;
 
   static mlir::LogicalResult
   verifyConstructionInvariants(mlir::Location, mlir::Type eleTy,
                                mlir::AffineMapAttr map);
 };
 
 /// The type of a pair that describes a CHARACTER variable. Specifically, a
 /// CHARACTER consists of a reference to a buffer (the string value) and a LEN
 /// type parameter (the runtime length of the buffer).
 class BoxCharType : public mlir::Type::TypeBase<BoxCharType, mlir::Type,
                                                 detail::BoxCharTypeStorage> {
 public:
   using Base::Base;
   static BoxCharType get(mlir::MLIRContext *ctxt, KindTy kind);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_BOXCHAR; }
   CharacterType getEleTy() const;
 };
 
 /// The type of a pair that describes a PROCEDURE reference. Pointers to
 /// internal procedures must carry an additional reference to the host's
 /// variables that are referenced.
 class BoxProcType : public mlir::Type::TypeBase<BoxProcType, mlir::Type,
                                                 detail::BoxProcTypeStorage> {
 public:
   using Base::Base;
   static BoxProcType get(mlir::Type eleTy);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_BOXPROC; }
   mlir::Type getEleTy() const;
 
   static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
                                                           mlir::Type eleTy);
 };
 
 /// The type of a runtime vector that describes triples of array dimension
 /// information. A triple consists of a lower bound, upper bound, and
 /// stride. Each dimension of an array entity may have an associated triple that
 /// maps how elements of the array are accessed.
 class DimsType : public mlir::Type::TypeBase<DimsType, mlir::Type,
                                              detail::DimsTypeStorage> {
 public:
   using Base::Base;
   static DimsType get(mlir::MLIRContext *ctx, unsigned rank);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_DIMS; }
 
   /// returns -1 if the rank is unknown
   unsigned getRank() const;
 };
 
 /// The type of a field name. Implementations may defer the layout of a Fortran
 /// derived type until runtime. This implies that the runtime must be able to
 /// determine the offset of fields within the entity.
 class FieldType : public mlir::Type::TypeBase<FieldType, mlir::Type,
                                               detail::FieldTypeStorage> {
 public:
   using Base::Base;
   static FieldType get(mlir::MLIRContext *ctxt);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_FIELD; }
 };
 
 /// The type of a heap pointer. Fortran entities with the ALLOCATABLE attribute
 /// may be allocated on the heap at runtime. These pointers are explicitly
 /// distinguished to disallow the composition of multiple levels of
 /// indirection. For example, an ALLOCATABLE POINTER is invalid.
 class HeapType : public mlir::Type::TypeBase<HeapType, mlir::Type,
                                              detail::HeapTypeStorage> {
 public:
   using Base::Base;
   static HeapType get(mlir::Type elementType);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_HEAP; }
 
   mlir::Type getEleTy() const;
 
   static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
                                                           mlir::Type eleTy);
 };
 
 /// The type of a LEN parameter name. Implementations may defer the layout of a
 /// Fortran derived type until runtime. This implies that the runtime must be
 /// able to determine the offset of LEN type parameters related to an entity.
 class LenType
     : public mlir::Type::TypeBase<LenType, mlir::Type, detail::LenTypeStorage> {
 public:
   using Base::Base;
   static LenType get(mlir::MLIRContext *ctxt);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_LEN; }
 };
 
 /// The type of entities with the POINTER attribute.  These pointers are
 /// explicitly distinguished to disallow the composition of multiple levels of
 /// indirection. For example, an ALLOCATABLE POINTER is invalid.
 class PointerType : public mlir::Type::TypeBase<PointerType, mlir::Type,
                                                 detail::PointerTypeStorage> {
 public:
   using Base::Base;
   static PointerType get(mlir::Type elementType);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_POINTER; }
 
   mlir::Type getEleTy() const;
 
   static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
                                                           mlir::Type eleTy);
 };
 
 /// The type of a reference to an entity in memory.
 class ReferenceType
     : public mlir::Type::TypeBase<ReferenceType, mlir::Type,
                                   detail::ReferenceTypeStorage> {
 public:
   using Base::Base;
   static ReferenceType get(mlir::Type elementType);
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_REFERENCE; }
 
   mlir::Type getEleTy() const;
 
   static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
                                                           mlir::Type eleTy);
 };
 
 /// A sequence type is a multi-dimensional array of values. The sequence type
public:
   /// one of constant shape (`array<C...xCxT>`), unknown shape
   /// (`array<*xT>`), or rows with shape and ending with column(s) of
   /// unknown extent (`array<C...xCx?...x?xT>`).
   bool hasConstantInterior() const;
 
   /// The value `-1` represents an unknown extent for a dimension
   static constexpr Extent getUnknownExtent() { return -1; }
 
-  static bool kindof(unsigned kind) { return kind == TypeKind::FIR_SEQUENCE; }
-
   static mlir::LogicalResult
   verifyConstructionInvariants(mlir::Location loc, const Shape &shape,
                                mlir::Type eleTy, mlir::AffineMapAttr map);
 };
 
 bool operator==(const SequenceType::Shape &, const SequenceType::Shape &);
 llvm::hash_code hash_value(const SequenceType::Extent &);
 llvm::hash_code hash_value(const SequenceType::Shape &);
 
 /// The type of a type descriptor object. The runtime may generate type
 /// descriptor objects to determine the type of an entity at runtime, etc.
 class TypeDescType : public mlir::Type::TypeBase<TypeDescType, mlir::Type,
                                                  detail::TypeDescTypeStorage> {
 public:
   using Base::Base;
   static TypeDescType get(mlir::Type ofType);
-  static constexpr bool kindof(unsigned kind) {
-    return kind == TypeKind::FIR_TYPEDESC;
-  }
   mlir::Type getOfTy() const;
 
   static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
                                                           mlir::Type ofType);
 };
 
 // Derived types
 
mlir::Type getType(unsigned index) {
     return getTypeList()[index].second;
   }
   unsigned getNumFields() { return getTypeList().size(); }
   unsigned getNumLenParams() { return getLenParamList().size(); }
 
   static RecordType get(mlir::MLIRContext *ctxt, llvm::StringRef name);
   void finalize(llvm::ArrayRef<TypePair> lenPList,
                 llvm::ArrayRef<TypePair> typeList);
-  static constexpr bool kindof(unsigned kind) { return kind == getId(); }
   static constexpr unsigned getId() { return TypeKind::FIR_DERIVED; }
 
   detail::RecordTypeStorage const *uniqueKey() const;
 
   static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
                                                           llvm::StringRef name);
 };
 

mlir/docs/Tutorials/DefiningAttributesAndTypes.md

 /// using the default storage class (TypeStorage) as the storage type.
 /// 'Type::TypeBase' also provides several utility methods to simplify type
 /// construction.
 class SimpleType : public Type::TypeBase<SimpleType, Type, TypeStorage> {
 public:
   /// Inherit some necessary constructors from 'TypeBase'.
   using Base::Base;
 
-  /// This static method is used to support type inquiry through isa, cast,
-  /// and dyn_cast.
-  static bool kindof(unsigned kind) { return kind == MyTypes::Simple; }
-
   /// This method is used to get an instance of the 'SimpleType'. Given that
   /// this is a parameterless type, it just needs to take the context for
   /// uniquing purposes.
   static SimpleType get(MLIRContext *context) {
     // Call into a helper 'get' method in 'TypeBase' to get a uniqued instance
     // of this type.
     return Base::get(context, MyTypes::Simple);
   }

 /// class (ComplexTypeStorage). 'Type::TypeBase' also provides several utility
 /// methods to simplify type construction and verification.
 class ComplexType : public Type::TypeBase<ComplexType, Type,
                                           ComplexTypeStorage> {
 public:
   /// Inherit some necessary constructors from 'TypeBase'.
   using Base::Base;
 
-  /// This static method is used to support type inquiry through isa, cast,
-  /// and dyn_cast.
-  static bool kindof(unsigned kind) { return kind == MyTypes::Complex; }
-
   /// This method is used to get an instance of the 'ComplexType'. This method
   /// asserts that all of the construction invariants were satisfied. To
   /// gracefully handle failed construction, getChecked should be used instead.
   static ComplexType get(unsigned param, Type type) {
     // Call into a helper 'get' method in 'TypeBase' to get a uniqued instance
     // of this type. All parameters to the storage class are passed after the
     // type kind.
     return Base::get(type.getContext(), MyTypes::Complex, param, type);

 
 ```c++
 class RecursiveType : public Type::TypeBase<RecursiveType, Type,
                                             RecursiveTypeStorage> {
 public:
   /// Inherit parent constructors.
   using Base::Base;
 
-  /// This static method is used to support type inquiry through isa, cast,
-  /// and dyn_cast.
-  static bool kindof(unsigned kind) { return kind == MyTypes::Recursive; }
-
   /// Creates an instance of the Recursive type. This only takes the type name
   /// and returns the type with uninitialized body.
   static RecursiveType get(MLIRContext *ctx, StringRef name) {
     // Call into the base to get a uniqued instance of this type. The parameter
     // (name) is passed after the kind.
     return Base::get(ctx, MyTypes::Recursive, name);
   }
 

mlir/docs/Tutorials/Toy/Ch-7.md

 /// (StructType), the base class to use (Type), and the storage class
 /// (StructTypeStorage).
 class StructType : public mlir::Type::TypeBase<StructType, mlir::Type,
                                                StructTypeStorage> {
 public:
   /// Inherit some necessary constructors from 'TypeBase'.
   using Base::Base;
 
-  /// This static method is used to support type inquiry through isa, cast,
-  /// and dyn_cast.
-  static bool kindof(unsigned kind) { return kind == ToyTypes::Struct; }
-
   /// Create an instance of a `StructType` with the given element types. There
   /// *must* be at least one element type.
   static StructType get(llvm::ArrayRef<mlir::Type> elementTypes) {
     assert(!elementTypes.empty() && "expected at least 1 element type");
 
     // Call into a helper 'get' method in 'TypeBase' to get a uniqued instance
     // of this type. The first two parameters are the context to unique in and
     // the kind of the type. The parameters after the type kind are forwarded to

mlir/examples/toy/Ch7/include/toy/Dialect.h

 /// (StructType), the base class to use (Type), and the storage class
 /// (StructTypeStorage).
 class StructType : public mlir::Type::TypeBase<StructType, mlir::Type,
                                                detail::StructTypeStorage> {
 public:
   /// Inherit some necessary constructors from 'TypeBase'.
   using Base::Base;
 
-  /// This static method is used to support type inquiry through isa, cast,
-  /// and dyn_cast.
-  static bool kindof(unsigned kind) { return kind == ToyTypes::Struct; }
-
   /// Create an instance of a `StructType` with the given element types. There
   /// *must* be atleast one element type.
   static StructType get(llvm::ArrayRef<mlir::Type> elementTypes);
 
   /// Returns the element types of this struct type.
   llvm::ArrayRef<mlir::Type> getElementTypes();
 
   /// Returns the number of element type held by this struct.
   size_t getNumElementTypes() { return getElementTypes().size(); }
 };
 } // end namespace toy
 } // end namespace mlir
 
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.h

 ///
 /// The LLVM dialect type system is closed: parametric types can only refer to
 /// other LLVM dialect types. This is consistent with LLVM IR and enables a more
 /// concise pretty-printing format.
 ///
 /// Similarly to other MLIR types, LLVM dialect types are owned by the MLIR
 /// context, have an immutable identifier (for most types except identified
 /// structs, the entire type is the identifier) and are thread-safe.
-class LLVMType : public Type::TypeBase<LLVMType, Type, TypeStorage> {
+class LLVMType : public Type {
 public:
   enum Kind {
     // Keep non-parametric types contiguous in the enum.
     VoidType = FIRST_LLVM_TYPE + 1,
     HalfType,
     BFloatType,
     FloatType,
     DoubleType,
enum Kind {
     StructType,
     FIRST_NEW_LLVM_TYPE = VoidType,
     LAST_NEW_LLVM_TYPE = StructType,
     FIRST_TRIVIAL_TYPE = VoidType,
     LAST_TRIVIAL_TYPE = MetadataType
   };
 
   /// Inherit base constructors.
-  using Base::Base;
+  using Type::Type;
 
   /// Support for PointerLikeTypeTraits.
   using Type::getAsOpaquePointer;
   static LLVMType getFromOpaquePointer(const void *ptr) {
     return LLVMType(static_cast<ImplType *>(const_cast<void *>(ptr)));
   }
 
   /// Support for isa/cast.
-  static bool kindof(unsigned kind) {
-    return FIRST_NEW_LLVM_TYPE <= kind && kind <= LAST_NEW_LLVM_TYPE;
+  static bool classof(Type type) {
+    return type.getKind() >= FIRST_NEW_LLVM_TYPE &&
+           type.getKind() <= LAST_NEW_LLVM_TYPE;
   }
 
   LLVMDialect &getDialect();
 
   /// Floating-point type utilities.
   bool isBFloatTy() { return isa<LLVMBFloatType>(); }
   bool isHalfTy() { return isa<LLVMHalfType>(); }
   bool isFloatTy() { return isa<LLVMFloatType>(); }

 // Trivial types.
 //===----------------------------------------------------------------------===//
 
 // Batch-define trivial types.
 #define DEFINE_TRIVIAL_LLVM_TYPE(ClassName, Kind)                              \
   class ClassName : public Type::TypeBase<ClassName, LLVMType, TypeStorage> {  \
   public:                                                                      \
     using Base::Base;                                                          \
-    static bool kindof(unsigned kind) { return kind == Kind; }                 \
     static ClassName get(MLIRContext *context) {                               \
       return Base::get(context, Kind);                                         \
     }                                                                          \
   }
 
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMVoidType, LLVMType::VoidType);
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMHalfType, LLVMType::HalfType);
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMBFloatType, LLVMType::BFloatType);

 /// elements in memory, parameterized by the number of elements and the element
 /// type.
 class LLVMArrayType : public Type::TypeBase<LLVMArrayType, LLVMType,
                                             detail::LLVMTypeAndSizeStorage> {
 public:
   /// Inherit base constructors.
   using Base::Base;
 
-  /// Support for isa/cast.
-  static bool kindof(unsigned kind) { return kind == LLVMType::ArrayType; }
-
   /// Gets or creates an instance of LLVM dialect array type containing
   /// `numElements` of `elementType`, in the same context as `elementType`.
   static LLVMArrayType get(LLVMType elementType, unsigned numElements);
 
   /// Returns the element type of the array.
   LLVMType getElementType();
 
   /// Returns the number of elements in the array type.

 /// variadic.
 class LLVMFunctionType
     : public Type::TypeBase<LLVMFunctionType, LLVMType,
                             detail::LLVMFunctionTypeStorage> {
 public:
   /// Inherit base constructors.
   using Base::Base;
 
-  /// Support for isa/cast.
-  static bool kindof(unsigned kind) { return kind == LLVMType::FunctionType; }
-
   /// Gets or creates an instance of LLVM dialect function in the same context
   /// as the `result` type.
   static LLVMFunctionType get(LLVMType result, ArrayRef<LLVMType> arguments,
                               bool isVarArg = false);
 
   /// Returns the result type of the function.
   LLVMType getReturnType();
 

 
 /// LLVM dialect signless integer type parameterized by bitwidth.
 class LLVMIntegerType : public Type::TypeBase<LLVMIntegerType, LLVMType,
                                               detail::LLVMIntegerTypeStorage> {
 public:
   /// Inherit base constructor.
   using Base::Base;
 
-  /// Support for isa/cast.
-  static bool kindof(unsigned kind) { return kind == LLVMType::IntegerType; }
-
   /// Gets or creates an instance of the integer of the specified `bitwidth` in
   /// the given context.
   static LLVMIntegerType get(MLIRContext *ctx, unsigned bitwidth);
 
   /// Returns the bitwidth of this integer type.
   unsigned getBitWidth();
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMPointerType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect pointer type. This type typically represents a reference to an
 /// object in memory. It is parameterized by the element type and the address
 /// space.
 class LLVMPointerType : public Type::TypeBase<LLVMPointerType, LLVMType,
                                               detail::LLVMPointerTypeStorage> {
 public:
   /// Inherit base constructors.
   using Base::Base;
 
-  /// Support for isa/cast.
-  static bool kindof(unsigned kind) { return kind == LLVMType::PointerType; }
-
   /// Gets or creates an instance of LLVM dialect pointer type pointing to an
   /// object of `pointee` type in the given address space. The pointer type is
   /// created in the same context as `pointee`.
   static LLVMPointerType get(LLVMType pointee, unsigned addressSpace = 0);
 
   /// Returns the pointed-to type.
   LLVMType getElementType();
 

 /// Note that the packedness of the struct takes place in uniquing of literal
 /// structs, but does not in uniquing of identified structs.
 class LLVMStructType : public Type::TypeBase<LLVMStructType, LLVMType,
                                              detail::LLVMStructTypeStorage> {
 public:
   /// Inherit base construtors.
   using Base::Base;
 
-  /// Support for isa/cast.
-  static bool kindof(unsigned kind) { return kind == LLVMType::StructType; }
-
   /// Gets or creates an identified struct with the given name in the provided
   /// context. Note that unlike llvm::StructType::create, this function will
   /// _NOT_ rename a struct in case a struct with the same name already exists
   /// in the context. Instead, it will just return the existing struct,
   /// similarly to the rest of MLIR type ::get methods.
   static LLVMStructType getIdentified(MLIRContext *context, StringRef name);
 
   /// Gets or creates a literal struct with the given body in the provided

 
 //===----------------------------------------------------------------------===//
 // LLVMVectorType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect vector type, represents a sequence of elements that can be
 /// processed as one, typically in SIMD context. This is a base class for fixed
 /// and scalable vectors.
-class LLVMVectorType : public Type::TypeBase<LLVMVectorType, LLVMType,
-                                             detail::LLVMTypeAndSizeStorage> {
+class LLVMVectorType : public LLVMType {
 public:
   /// Inherit base constructor.
-  using Base::Base;
+  using LLVMType::LLVMType;
 
-  /// Support for isa/cast.
-  static bool kindof(unsigned kind) {
-    return kind == LLVMType::FixedVectorType ||
-           kind == LLVMType::ScalableVectorType;
-  }
+  /// Support type casting functionality.
+  static bool classof(Type type);
 
   /// Returns the element type of the vector.
   LLVMType getElementType();
 
   /// Returns the number of elements in the vector.
   llvm::ElementCount getElementCount();
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMFixedVectorType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect fixed vector type, represents a sequence of elements of known
 /// length that can be processed as one.
 class LLVMFixedVectorType
     : public Type::TypeBase<LLVMFixedVectorType, LLVMVectorType,
                             detail::LLVMTypeAndSizeStorage> {
 public:
   /// Inherit base constructor.
   using Base::Base;
 
-  /// Support for isa/cast.
-  static bool kindof(unsigned kind) {
-    return kind == LLVMType::FixedVectorType;
-  }
-
   /// Gets or creates a fixed vector type containing `numElements` of
   /// `elementType` in the same context as `elementType`.
   static LLVMFixedVectorType get(LLVMType elementType, unsigned numElements);
 
   /// Returns the number of elements in the fixed vector.
   unsigned getNumElements();
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMScalableVectorType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect scalable vector type, represents a sequence of elements of
 /// unknown length that is known to be divisible by some constant. These
 /// elements can be processed as one in SIMD context.
 class LLVMScalableVectorType
     : public Type::TypeBase<LLVMScalableVectorType, LLVMVectorType,
                             detail::LLVMTypeAndSizeStorage> {
 public:
   /// Inherit base constructor.
   using Base::Base;
 
-  /// Support for isa/cast.
-  static bool kindof(unsigned kind) {
-    return kind == LLVMType::ScalableVectorType;
-  }
-
   /// Gets or creates a scalable vector type containing a non-zero multiple of
   /// `minNumElements` of `elementType` in the same context as `elementType`.
   static LLVMScalableVectorType get(LLVMType elementType,
                                     unsigned minNumElements);
 
   /// Returns the scaling factor of the number of elements in the vector. The
   /// vector contains at least the resulting number of elements, or any non-zero
   /// multiple of this number.

mlir/include/mlir/Dialect/Linalg/IR/LinalgTypes.h

 public:
   // Used for generic hooks in TypeBase.
   using Base::Base;
   /// Construction hook.
   static RangeType get(MLIRContext *context) {
     /// Custom, uniq'ed construction in the MLIRContext.
     return Base::get(context, LinalgTypes::Range);
   }
-  /// Used to implement llvm-style cast.
-  static bool kindof(unsigned kind) { return kind == LinalgTypes::Range; }
 };
 
 } // namespace linalg
 } // namespace mlir
 
 #endif // MLIR_DIALECT_LINALG_LINALGTYPES_H_

mlir/include/mlir/Dialect/Quant/QuantTypes.h

 ///
 /// Note that for the any type, the expressed type is optional.
 class AnyQuantizedType
     : public Type::TypeBase<AnyQuantizedType, QuantizedType,
                             detail::AnyQuantizedTypeStorage> {
 public:
   using Base::Base;
 
-  /// Support method to enable LLVM-style type casting.
-  static bool kindof(unsigned kind) { return kind == QuantizationTypes::Any; }
-
   /// Gets an instance of the type with all parameters specified but not
   /// checked.
   static AnyQuantizedType get(unsigned flags, Type storageType,
                               Type expressedType, int64_t storageTypeMin,
                               int64_t storageTypeMax);
 
   /// Gets an instance of the type with all specified parameters checked.
   /// Returns a nullptr convertible type on failure.
public:
 
   /// Verifies construction invariants and issues errors/warnings.
   static LogicalResult
   verifyConstructionInvariants(Location loc, unsigned flags, Type storageType,
                                Type expressedType, double scale,
                                int64_t zeroPoint, int64_t storageTypeMin,
                                int64_t storageTypeMax);
 
-  /// Support method to enable LLVM-style type casting.
-  static bool kindof(unsigned kind) {
-    return kind == QuantizationTypes::UniformQuantized;
-  }
-
   /// Gets the scale term. The scale designates the difference between the real
   /// values corresponding to consecutive quantized values differing by 1.
   double getScale() const;
 
   /// Gets the storage value corresponding to the real value 0 in the affine
   /// equation.
   int64_t getZeroPoint() const;
 
public:
   /// Verifies construction invariants and issues errors/warnings.
   static LogicalResult
   verifyConstructionInvariants(Location loc, unsigned flags, Type storageType,
                                Type expressedType, ArrayRef<double> scales,
                                ArrayRef<int64_t> zeroPoints,
                                int32_t quantizedDimension,
                                int64_t storageTypeMin, int64_t storageTypeMax);
 
-  /// Support method to enable LLVM-style type casting.
-  static bool kindof(unsigned kind) {
-    return kind == QuantizationTypes::UniformQuantizedPerAxis;
-  }
-
   /// Gets the quantization scales. The scales designate the difference between
   /// the real values corresponding to consecutive quantized values differing
   /// by 1. The ith scale corresponds to the ith slice in the
   /// quantized_dimension.
   ArrayRef<double> getScales() const;
 
   /// Gets the storage values corresponding to the real value 0 in the affine
   /// equation. The ith zero point corresponds to the ith slice in the

mlir/include/mlir/Dialect/SPIRV/SPIRVAttributes.h

public:
   uint32_t getDescriptorSet();
 
   /// Returns binding.
   uint32_t getBinding();
 
   /// Returns `spirv::StorageClass`.
   Optional<StorageClass> getStorageClass();
 
-  static bool kindof(unsigned kind) {
-    return kind == AttrKind::InterfaceVarABI;
-  }
-
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     IntegerAttr descriptorSet,
                                                     IntegerAttr binding,
                                                     IntegerAttr storageClass);
 };
 
 /// An attribute that specifies the SPIR-V (version, capabilities, extensions)
 /// triple.
public:
   };
   using cap_range = llvm::iterator_range<cap_iterator>;
 
   /// Returns the capabilities.
   cap_range getCapabilities();
   /// Returns the capabilities as an integer array attribute.
   ArrayAttr getCapabilitiesAttr();
 
-  static bool kindof(unsigned kind) { return kind == AttrKind::VerCapExt; }
-
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     IntegerAttr version,
                                                     ArrayAttr capabilities,
                                                     ArrayAttr extensions);
 };
 
 /// An attribute that specifies the target version, allowed extensions and
 /// capabilities, and resource limits. These information describes a SPIR-V
public:
   /// Returns the target capabilities.
   VerCapExtAttr::cap_range getCapabilities();
   /// Returns the target capabilities as an integer array attribute.
   ArrayAttr getCapabilitiesAttr();
 
   /// Returns the target resource limits.
   ResourceLimitsAttr getResourceLimits();
 
-  static bool kindof(unsigned kind) { return kind == AttrKind::TargetEnv; }
-
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     VerCapExtAttr triple,
                                                     DictionaryAttr limits);
 };
 } // namespace spirv
 } // namespace mlir
 
 #endif // MLIR_DIALECT_SPIRV_SPIRVATTRIBUTES_H

mlir/include/mlir/Dialect/SPIRV/SPIRVTypes.h

 };
 
 // SPIR-V array type
 class ArrayType : public Type::TypeBase<ArrayType, CompositeType,
                                         detail::ArrayTypeStorage> {
 public:
   using Base::Base;
 
-  static bool kindof(unsigned kind) { return kind == TypeKind::Array; }
-
   static ArrayType get(Type elementType, unsigned elementCount);
 
   /// Returns an array type with the given stride in bytes.
   static ArrayType get(Type elementType, unsigned elementCount,
                        unsigned stride);
 
   unsigned getNumElements() const;
 

 };
 
 // SPIR-V image type
 class ImageType
     : public Type::TypeBase<ImageType, SPIRVType, detail::ImageTypeStorage> {
 public:
   using Base::Base;
 
-  static bool kindof(unsigned kind) { return kind == TypeKind::Image; }
-
   static ImageType
   get(Type elementType, Dim dim,
       ImageDepthInfo depth = ImageDepthInfo::DepthUnknown,
       ImageArrayedInfo arrayed = ImageArrayedInfo::NonArrayed,
       ImageSamplingInfo samplingInfo = ImageSamplingInfo::SingleSampled,
       ImageSamplerUseInfo samplerUse = ImageSamplerUseInfo::SamplerUnknown,
       ImageFormat format = ImageFormat::Unknown) {
     return ImageType::get(

 };
 
 // SPIR-V pointer type
 class PointerType : public Type::TypeBase<PointerType, SPIRVType,
                                           detail::PointerTypeStorage> {
 public:
   using Base::Base;
 
-  static bool kindof(unsigned kind) { return kind == TypeKind::Pointer; }
-
   static PointerType get(Type pointeeType, StorageClass storageClass);
 
   Type getPointeeType() const;
 
   StorageClass getStorageClass() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
                      Optional<spirv::StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
                        Optional<spirv::StorageClass> storage = llvm::None);
 };
 
 // SPIR-V run-time array type
 class RuntimeArrayType
     : public Type::TypeBase<RuntimeArrayType, SPIRVType,
                             detail::RuntimeArrayTypeStorage> {
 public:
   using Base::Base;
 
-  static bool kindof(unsigned kind) { return kind == TypeKind::RuntimeArray; }
-
   static RuntimeArrayType get(Type elementType);
 
   /// Returns a runtime array type with the given stride in bytes.
   static RuntimeArrayType get(Type elementType, unsigned stride);
 
   Type getElementType() const;
 
   /// Returns the array stride in bytes. 0 means no stride decorated on this
struct MemberDecorationInfo {
     bool operator<(const MemberDecorationInfo &other) const {
       return this->memberIndex < other.memberIndex ||
              (this->memberIndex == other.memberIndex &&
               static_cast<uint32_t>(this->decoration) <
                   static_cast<uint32_t>(other.decoration));
     }
   };
 
-  static bool kindof(unsigned kind) { return kind == TypeKind::Struct; }
-
   /// Construct a StructType with at least one member.
   static StructType get(ArrayRef<Type> memberTypes,
                         ArrayRef<OffsetInfo> offsetInfo = {},
                         ArrayRef<MemberDecorationInfo> memberDecorations = {});
 
   /// Construct a struct with no members.
   static StructType getEmpty(MLIRContext *context);
 

 
 // SPIR-V cooperative matrix type
 class CooperativeMatrixNVType
     : public Type::TypeBase<CooperativeMatrixNVType, CompositeType,
                             detail::CooperativeMatrixTypeStorage> {
 public:
   using Base::Base;
 
-  static bool kindof(unsigned kind) {
-    return kind == TypeKind::CooperativeMatrix;
-  }
-
   static CooperativeMatrixNVType get(Type elementType, spirv::Scope scope,
                                      unsigned rows, unsigned columns);
   Type getElementType() const;
 
   /// Return the scope of the cooperative matrix.
   spirv::Scope getScope() const;
   /// return the number of rows of the matrix.
   unsigned getRows() const;
   /// return the number of columns of the matrix.
   unsigned getColumns() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
                      Optional<spirv::StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
                        Optional<spirv::StorageClass> storage = llvm::None);
 };
 
 // SPIR-V matrix type
 class MatrixType : public Type::TypeBase<MatrixType, CompositeType,
                                          detail::MatrixTypeStorage> {
 public:
   using Base::Base;
 
-  static bool kindof(unsigned kind) { return kind == TypeKind::Matrix; }
-
   static MatrixType get(Type columnType, uint32_t columnCount);
 
   static MatrixType getChecked(Type columnType, uint32_t columnCount,
                                Location location);
 
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     Type columnType,
                                                     uint32_t columnCount);

mlir/include/mlir/Dialect/Shape/IR/Shape.h

 /// The component type corresponding to shape, element type and attribute.
 class ComponentType : public Type::TypeBase<ComponentType, Type, TypeStorage> {
 public:
   using Base::Base;
 
   static ComponentType get(MLIRContext *context) {
     return Base::get(context, ShapeTypes::Kind::Component);
   }
-
-  /// Support method to enable LLVM-style type casting.
-  static bool kindof(unsigned kind) {
-    return kind == ShapeTypes::Kind::Component;
-  }
 };
 
 /// The element type of the shaped type.
 class ElementType : public Type::TypeBase<ElementType, Type, TypeStorage> {
 public:
   using Base::Base;
 
   static ElementType get(MLIRContext *context) {
     return Base::get(context, ShapeTypes::Kind::Element);
   }
-
-  /// Support method to enable LLVM-style type casting.
-  static bool kindof(unsigned kind) {
-    return kind == ShapeTypes::Kind::Element;
-  }
 };
 
 /// The shape descriptor type represents rank and dimension sizes.
 class ShapeType : public Type::TypeBase<ShapeType, Type, TypeStorage> {
 public:
   using Base::Base;
 
   static ShapeType get(MLIRContext *context) {
     return Base::get(context, ShapeTypes::Kind::Shape);
   }
-
-  /// Support method to enable LLVM-style type casting.
-  static bool kindof(unsigned kind) { return kind == ShapeTypes::Kind::Shape; }
 };
 
 /// The type of a single dimension.
 class SizeType : public Type::TypeBase<SizeType, Type, TypeStorage> {
 public:
   using Base::Base;
 
   static SizeType get(MLIRContext *context) {
     return Base::get(context, ShapeTypes::Kind::Size);
   }
-
-  /// Support method to enable LLVM-style type casting.
-  static bool kindof(unsigned kind) { return kind == ShapeTypes::Kind::Size; }
 };
 
 /// The ValueShape represents a (potentially unknown) runtime value and shape.
 class ValueShapeType
     : public Type::TypeBase<ValueShapeType, Type, TypeStorage> {
 public:
   using Base::Base;
 
   static ValueShapeType get(MLIRContext *context) {
     return Base::get(context, ShapeTypes::Kind::ValueShape);
   }
-
-  /// Support method to enable LLVM-style type casting.
-  static bool kindof(unsigned kind) {
-    return kind == ShapeTypes::Kind::ValueShape;
-  }
 };
 
 /// The Witness represents a runtime constraint, to be used as shape related
 /// preconditions on code execution.
 class WitnessType : public Type::TypeBase<WitnessType, Type, TypeStorage> {
 public:
   using Base::Base;
 
   static WitnessType get(MLIRContext *context) {
     return Base::get(context, ShapeTypes::Kind::Witness);
   }
-
-  /// Support method to enable LLVM-style type casting.
-  static bool kindof(unsigned kind) {
-    return kind == ShapeTypes::Kind::Witness;
-  }
 };
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Shape/IR/ShapeOps.h.inc"
 
 #include "mlir/Dialect/Shape/IR/ShapeOpsDialect.h.inc"
 
 } // namespace shape
 } // namespace mlir
 
 #endif // MLIR_SHAPE_IR_SHAPE_H

mlir/include/mlir/IR/AttributeSupport.h

 public:
   /// Look up the specified abstract attribute in the MLIRContext and return a
   /// reference to it.
   static const AbstractAttribute &lookup(TypeID typeID, MLIRContext *context);
 
   /// This method is used by Dialect objects when they register the list of
   /// attributes they contain.
   template <typename T> static AbstractAttribute get(Dialect &dialect) {
-    return AbstractAttribute(dialect, T::getInterfaceMap());
+    return AbstractAttribute(dialect, T::getInterfaceMap(), T::getTypeID());
   }
 
   /// Return the dialect this attribute was registered to.
   Dialect &getDialect() const { return const_cast<Dialect &>(dialect); }
 
   /// Returns an instance of the concept object for the given interface if it
   /// was registered to this attribute, null otherwise. This should not be used
   /// directly.
   template <typename T> typename T::Concept *getInterface() const {
     return interfaceMap.lookup<T>();
   }
 
+  /// Return the unique identifier representing the concrete attribute class.
+  TypeID getTypeID() const { return typeID; }
+
 private:
-  AbstractAttribute(Dialect &dialect, detail::InterfaceMap &&interfaceMap)
-      : dialect(dialect), interfaceMap(std::move(interfaceMap)) {}
+  AbstractAttribute(Dialect &dialect, detail::InterfaceMap &&interfaceMap,
+                    TypeID typeID)
+      : dialect(dialect), interfaceMap(std::move(interfaceMap)),
+        typeID(typeID) {}
 
   /// This is the dialect that this attribute was registered to.
   Dialect &dialect;
 
   /// This is a collection of the interfaces registered to this attribute.
   detail::InterfaceMap interfaceMap;
+
+  /// The unique identifier of the derived Attribute class.
+  TypeID typeID;
 };
 
 //===----------------------------------------------------------------------===//
 // AttributeStorage
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 class AttributeUniquer;

mlir/include/mlir/IR/Attributes.h

#include "DialectSymbolRegistry.def"
   template <typename U> U cast() const;
 
   // Support dyn_cast'ing Attribute to itself.
   static bool classof(Attribute) { return true; }
 
   /// Return the classification for this attribute.
   unsigned getKind() const { return impl->getKind(); }
 
+  /// Return a unique identifier for the concrete attribute type. This is used
+  /// to support dynamic type casting.
+  TypeID getTypeID() { return impl->getAbstractAttribute().getTypeID(); }
+
   /// Return the type of this attribute.
   Type getType() const;
 
   /// Return the context this attribute belongs to.
   MLIRContext *getContext() const;
 
   /// Get the dialect this attribute is registered to.
   Dialect &getDialect() const;
: public Attribute::AttrBase<AffineMapAttr, Attribute,
                                  detail::AffineMapAttributeStorage> {
 public:
   using Base::Base;
   using ValueType = AffineMap;
 
   static AffineMapAttr get(AffineMap value);
 
   AffineMap getValue() const;
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::AffineMap;
-  }
 };
 
 //===----------------------------------------------------------------------===//
 // ArrayAttr
 //===----------------------------------------------------------------------===//
 
 /// Array attributes are lists of other attributes.  They are not necessarily
 /// type homogenous given that attributes don't, in general, carry types.
public:
 
   /// Support range iteration.
   using iterator = llvm::ArrayRef<Attribute>::iterator;
   iterator begin() const { return getValue().begin(); }
   iterator end() const { return getValue().end(); }
   size_t size() const { return getValue().size(); }
   bool empty() const { return size() == 0; }
 
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::Array;
-  }
-
 private:
   /// Class for underlying value iterator support.
   template <typename AttrTy>
   class attr_value_iterator final
       : public llvm::mapped_iterator<ArrayAttr::iterator,
                                      AttrTy (*)(Attribute)> {
   public:
     explicit attr_value_iterator(ArrayAttr::iterator it)
static bool sort(ArrayRef<NamedAttribute> values,
                    SmallVectorImpl<NamedAttribute> &storage);
 
   /// Sorts the NamedAttributes in the array ordered by name as expected by
   /// getWithSorted in place on an array and returns whether the values needed
   /// to be sorted.
   /// Requires: uniquely named attributes.
   static bool sortInPlace(SmallVectorImpl<NamedAttribute> &array);
 
-  /// Methods for supporting type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::Dictionary;
-  }
-
 private:
   /// Return empty dictionary.
   static DictionaryAttr getEmpty(MLIRContext *context);
 };
 
 //===----------------------------------------------------------------------===//
 // FloatAttr
 //===----------------------------------------------------------------------===//
public:
 
   APFloat getValue() const;
 
   /// This function is used to convert the value to a double, even if it loses
   /// precision.
   double getValueAsDouble() const;
   static double getValueAsDouble(APFloat val);
 
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::Float;
-  }
-
   /// Verify the construction invariants for a double value.
   static LogicalResult verifyConstructionInvariants(Location loc, Type type,
                                                     double value);
   static LogicalResult verifyConstructionInvariants(Location loc, Type type,
                                                     const APFloat &value);
 };
 
 //===----------------------------------------------------------------------===//
public:
   int64_t getInt() const;
   /// Return the integer value as a signed 64-bit int. The attribute must be
   /// a signed integer.
   int64_t getSInt() const;
   /// Return the integer value as a unsigned 64-bit int. The attribute must be
   /// an unsigned integer.
   uint64_t getUInt() const;
 
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::Integer;
-  }
-
   static LogicalResult verifyConstructionInvariants(Location loc, Type type,
                                                     int64_t value);
   static LogicalResult verifyConstructionInvariants(Location loc, Type type,
                                                     const APInt &value);
 };
 
 //===----------------------------------------------------------------------===//
 // BoolAttr
: public Attribute::AttrBase<IntegerSetAttr, Attribute,
                                  detail::IntegerSetAttributeStorage> {
 public:
   using Base::Base;
   using ValueType = IntegerSet;
 
   static IntegerSetAttr get(IntegerSet value);
 
   IntegerSet getValue() const;
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::IntegerSet;
-  }
 };
 
 //===----------------------------------------------------------------------===//
 // OpaqueAttr
 //===----------------------------------------------------------------------===//
 
 /// Opaque attributes represent attributes of non-registered dialects. These are
 /// attribute represented in their raw string form, and can only usefully be
public:
   /// Returns the raw attribute data of the opaque attribute.
   StringRef getAttrData() const;
 
   /// Verify the construction of an opaque attribute.
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     Identifier dialect,
                                                     StringRef attrData,
                                                     Type type);
-
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::Opaque;
-  }
 };
 
 //===----------------------------------------------------------------------===//
 // StringAttr
 //===----------------------------------------------------------------------===//
 
 class StringAttr : public Attribute::AttrBase<StringAttr, Attribute,
                                               detail::StringAttributeStorage> {
 public:
   using Base::Base;
   using ValueType = StringRef;
 
   /// Get an instance of a StringAttr with the given string.
   static StringAttr get(StringRef bytes, MLIRContext *context);
 
   /// Get an instance of a StringAttr with the given string and Type.
   static StringAttr get(StringRef bytes, Type type);
 
   StringRef getValue() const;
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::String;
-  }
 };
 
 //===----------------------------------------------------------------------===//
 // SymbolRefAttr
 //===----------------------------------------------------------------------===//
 
 class FlatSymbolRefAttr;
 
public:
 
   /// Returns the name of the fully resolved symbol, i.e. the leaf of the
   /// reference path.
   StringRef getLeafReference() const;
 
   /// Returns the set of nested references representing the path to the symbol
   /// nested under the root reference.
   ArrayRef<FlatSymbolRefAttr> getNestedReferences() const;
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::SymbolRef;
-  }
 };
 
 /// A symbol reference with a reference path containing a single element. This
 /// is used to refer to an operation within the current symbol table.
 class FlatSymbolRefAttr : public SymbolRefAttr {
 public:
   using SymbolRefAttr::SymbolRefAttr;
   using ValueType = StringRef;
class TypeAttr : public Attribute::AttrBase<TypeAttr, Attribute,
                                             detail::TypeAttributeStorage> {
 public:
   using Base::Base;
   using ValueType = Type;
 
   static TypeAttr get(Type value);
 
   Type getValue() const;
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) { return kind == StandardAttributes::Type; }
 };
 
 //===----------------------------------------------------------------------===//
 // UnitAttr
 //===----------------------------------------------------------------------===//
 
 /// Unit attributes are attributes that hold no specific value and are given
 /// meaning by their existence.
 class UnitAttr
     : public Attribute::AttrBase<UnitAttr, Attribute, AttributeStorage> {
 public:
   using Base::Base;
 
   static UnitAttr get(MLIRContext *context);
-
-  static bool kindof(unsigned kind) { return kind == StandardAttributes::Unit; }
 };
 
 //===----------------------------------------------------------------------===//
 // Elements Attributes
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 template <typename T> class ElementsAttrIterator;

 /// storing and querying a list of densely packed strings.
 class DenseStringElementsAttr
     : public Attribute::AttrBase<DenseStringElementsAttr, DenseElementsAttr,
                                  detail::DenseStringElementsAttributeStorage> {
 
 public:
   using Base::Base;
 
-  /// Method for support type inquiry through isa, cast and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::DenseStringElements;
-  }
-
   /// Overload of the raw 'get' method that asserts that the given type is of
   /// integer or floating-point type. This method is used to verify type
   /// invariants that the templatized 'get' method cannot.
   static DenseStringElementsAttr get(ShapedType type, ArrayRef<StringRef> data);
 
 protected:
   friend DenseElementsAttr;
 };
 
 /// An attribute class for specializing behavior of Int and Floating-point
 /// densely packed string arrays.
 class DenseIntOrFPElementsAttr
     : public Attribute::AttrBase<DenseIntOrFPElementsAttr, DenseElementsAttr,
                                  detail::DenseIntOrFPElementsAttributeStorage> {
 
 public:
   using Base::Base;
 
-  /// Method for support type inquiry through isa, cast and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::DenseIntOrFPElements;
-  }
-
 protected:
   friend DenseElementsAttr;
 
   /// Constructs a dense elements attribute from an array of raw APFloat values.
   /// Each APFloat value is expected to have the same bitwidth as the element
   /// type of 'type'. 'type' must be a vector or tensor with static shape.
   static DenseElementsAttr getRaw(ShapedType type, size_t storageWidth,
                                   ArrayRef<APFloat> values, bool isSplat);
public:
 
   /// Decodes the attribute value using dialect-specific decoding hook.
   /// Returns false if decoding is successful. If not, returns true and leaves
   /// 'result' argument unspecified.
   bool decode(ElementsAttr &result);
 
   /// Returns dialect associated with this opaque constant.
   Dialect *getDialect() const;
-
-  /// Method for support type inquiry through isa, cast and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::OpaqueElements;
-  }
 };
 
 /// An attribute that represents a reference to a sparse vector or tensor
 /// object.
 ///
 /// This class uses COO (coordinate list) encoding to represent the sparse
 /// elements in an element attribute. Specifically, the sparse vector/tensor
 /// stores the indices and values as two separate dense elements attributes of
template <typename T> llvm::iterator_range<iterator<T>> getValues() const {
     };
     return llvm::map_range(llvm::seq<ptrdiff_t>(0, getNumElements()), mapFn);
   }
 
   /// Return the value of the element at the given index. The 'index' is
   /// expected to refer to a valid element.
   Attribute getValue(ArrayRef<uint64_t> index) const;
 
-  /// Method for support type inquiry through isa, cast and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::SparseElements;
-  }
-
 private:
   /// Get a zero APFloat for the given sparse attribute.
   APFloat getZeroAPFloat() const;
 
   /// Get a zero APInt for the given sparse attribute.
   APInt getZeroAPInt() const;
 
   /// Get a zero attribute for the given sparse attribute.

mlir/include/mlir/IR/Location.h

public:
   /// outermost.
   static Location get(Location name, ArrayRef<Location> frames);
 
   /// The concrete location information this object presents.
   Location getCallee() const;
 
   /// The caller's location.
   Location getCaller() const;
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::CallSiteLocation;
-  }
 };
 
 /// Represents a location derived from a file/line/column location.  The column
 /// and line may be zero to represent unknown column and/or unknown line/column
 /// information.
 class FileLineColLoc
     : public Attribute::AttrBase<FileLineColLoc, LocationAttr,
                                  detail::FileLineColLocationStorage> {
 public:
   using Base::Base;
 
   /// Return a uniqued FileLineCol location object.
   static Location get(Identifier filename, unsigned line, unsigned column,
                       MLIRContext *context);
   static Location get(StringRef filename, unsigned line, unsigned column,
                       MLIRContext *context);
 
   StringRef getFilename() const;
 
   unsigned getLine() const;
   unsigned getColumn() const;
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::FileLineColLocation;
-  }
 };
 
 /// Represents a value composed of multiple source constructs, with an optional
 /// metadata attribute.
 class FusedLoc : public Attribute::AttrBase<FusedLoc, LocationAttr,
                                             detail::FusedLocationStorage> {
 public:
   using Base::Base;
 
   /// Return a uniqued Fused Location object. The first location in the list
   /// will get precedence during diagnostic emission, with the rest being
   /// displayed as supplementary "fused from here" style notes.
   static Location get(ArrayRef<Location> locs, Attribute metadata,
                       MLIRContext *context);
   static Location get(ArrayRef<Location> locs, MLIRContext *context) {
     return get(locs, Attribute(), context);
   }
 
   ArrayRef<Location> getLocations() const;
 
   /// Returns the optional metadata attached to this fused location. Given that
   /// it is optional, the return value may be a null node.
   Attribute getMetadata() const;
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::FusedLocation;
-  }
 };
 
 /// Represents an identity name attached to a child location.
 class NameLoc : public Attribute::AttrBase<NameLoc, LocationAttr,
                                            detail::NameLocationStorage> {
 public:
   using Base::Base;
 
   /// Return a uniqued name location object. The child location must not be
   /// another NameLoc.
   static Location get(Identifier name, Location child);
 
   /// Return a uniqued name location object with an unknown child.
   static Location get(Identifier name, MLIRContext *context);
 
   /// Return the name identifier.
   Identifier getName() const;
 
   /// Return the child location.
   Location getChildLoc() const;
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::NameLocation;
-  }
 };
 
 /// Represents an unknown location.  This is always a singleton for a given
 /// MLIRContext.
 class UnknownLoc
     : public Attribute::AttrBase<UnknownLoc, LocationAttr, AttributeStorage> {
 public:
   using Base::Base;
 
   /// Get an instance of the UnknownLoc.
   static Location get(MLIRContext *context);
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind == StandardAttributes::UnknownLocation;
-  }
 };
 
 /// Represents a location that is external to MLIR. Contains a pointer to some
 /// data structure and an optional location that can be used if the first one is
 /// not suitable. Since it contains an external structure, only optional
 /// location is used during serialization.
 /// The class also provides a number of methods for making type-safe casts
 /// between a pointer to an object and opaque location.
public:
   uintptr_t getUnderlyingLocation() const;
 
   /// Returns a TypeID that represents the underlying objects c++ type.
   TypeID getUnderlyingTypeID() 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, TypeID typeID,
                       Location fallbackLocation);
 };
 
 // Make Location hashable.
 inline ::llvm::hash_code hash_value(Location arg) {
   return hash_value(arg.impl);

mlir/include/mlir/IR/StandardTypes.h

public:
   /// isn't supported.
   static ComplexType getChecked(Type elementType, Location location);
 
   /// Verify the construction of an integer type.
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     Type elementType);
 
   Type getElementType();
-
-  static bool kindof(unsigned kind) { return kind == StandardTypes::Complex; }
 };
 
 //===----------------------------------------------------------------------===//
 // IndexType
 //===----------------------------------------------------------------------===//
 
 /// Index is a special integer-like type with unknown platform-dependent bit
 /// width.
 class IndexType : public Type::TypeBase<IndexType, Type, TypeStorage> {
 public:
   using Base::Base;
 
   /// Get an instance of the IndexType.
   static IndexType get(MLIRContext *context);
 
-  /// Support method to enable LLVM-style type casting.
-  static bool kindof(unsigned kind) { return kind == StandardTypes::Index; }
-
   /// Storage bit width used for IndexType by internal compiler data structures.
   static constexpr unsigned kInternalStorageBitWidth = 64;
 };
 
 //===----------------------------------------------------------------------===//
 // IntegerType
 //===----------------------------------------------------------------------===//
 
public:
 
   /// Return true if this is a signless integer type.
   bool isSignless() const { return getSignedness() == Signless; }
   /// Return true if this is a signed integer type.
   bool isSigned() const { return getSignedness() == Signed; }
   /// Return true if this is an unsigned integer type.
   bool isUnsigned() const { return getSignedness() == Unsigned; }
 
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) { return kind == StandardTypes::Integer; }
-
   /// Integer representation maximal bitwidth.
   static constexpr unsigned kMaxWidth = 4096;
 };
 
 //===----------------------------------------------------------------------===//
 // FloatType
 //===----------------------------------------------------------------------===//
 
public:
   }
   static FloatType getF32(MLIRContext *ctx) {
     return get(StandardTypes::F32, ctx);
   }
   static FloatType getF64(MLIRContext *ctx) {
     return get(StandardTypes::F64, ctx);
   }
 
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) {
-    return kind >= StandardTypes::FIRST_FLOATING_POINT_TYPE &&
-           kind <= StandardTypes::LAST_FLOATING_POINT_TYPE;
-  }
-
   /// Return the bitwidth of this float type.
   unsigned getWidth();
 
   /// Return the floating semantics of this float type.
   const llvm::fltSemantics &getFloatSemantics();
 };
 
 //===----------------------------------------------------------------------===//
 // NoneType
 //===----------------------------------------------------------------------===//
 
 /// NoneType is a unit type, i.e. a type with exactly one possible value, where
 /// its value does not have a defined dynamic representation.
 class NoneType : public Type::TypeBase<NoneType, Type, TypeStorage> {
 public:
   using Base::Base;
 
   /// Get an instance of the NoneType.
   static NoneType get(MLIRContext *context);
-
-  static bool kindof(unsigned kind) { return kind == StandardTypes::None; }
 };
 
 //===----------------------------------------------------------------------===//
 // ShapedType
 //===----------------------------------------------------------------------===//
 
 /// This is a common base class between Vector, UnrankedTensor, RankedTensor,
 /// and MemRef types because they share behavior and semantics around shape,
public:
 
   /// Returns true of the given type can be used as an element of a vector type.
   /// In particular, vectors can consist of integer or float primitives.
   static bool isValidElementType(Type t) {
     return t.isa<IntegerType, FloatType>();
   }
 
   ArrayRef<int64_t> getShape() const;
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) { return kind == StandardTypes::Vector; }
 };
 
 //===----------------------------------------------------------------------===//
 // TensorType
 //===----------------------------------------------------------------------===//
 
 /// Tensor types represent multi-dimensional arrays, and have two variants:
 /// RankedTensorType and UnrankedTensorType.
static RankedTensorType getChecked(ArrayRef<int64_t> shape, Type elementType,
                                      Location location);
 
   /// Verify the construction of a ranked tensor type.
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     ArrayRef<int64_t> shape,
                                                     Type elementType);
 
   ArrayRef<int64_t> getShape() const;
-
-  static bool kindof(unsigned kind) {
-    return kind == StandardTypes::RankedTensor;
-  }
 };
 
 //===----------------------------------------------------------------------===//
 // UnrankedTensorType
 
 /// Unranked tensor types represent multi-dimensional arrays that have an
 /// unknown shape.
 class UnrankedTensorType
public:
   /// errors and return a nullptr-wrapping type.
   static UnrankedTensorType getChecked(Type elementType, Location location);
 
   /// Verify the construction of a unranked tensor type.
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     Type elementType);
 
   ArrayRef<int64_t> getShape() const { return llvm::None; }
-
-  static bool kindof(unsigned kind) {
-    return kind == StandardTypes::UnrankedTensor;
-  }
 };
 
 //===----------------------------------------------------------------------===//
 // BaseMemRefType
 //===----------------------------------------------------------------------===//
 
 /// Base MemRef for Ranked and Unranked variants
 class BaseMemRefType : public ShapedType {
public:
 
   // TODO: merge these two special values in a single one used everywhere.
   // Unfortunately, uses of `-1` have crept deep into the codebase now and are
   // hard to track.
   static int64_t getDynamicStrideOrOffset() {
     return ShapedType::kDynamicStrideOrOffset;
   }
 
-  static bool kindof(unsigned kind) { return kind == StandardTypes::MemRef; }
-
 private:
   /// Get or create a new MemRefType defined by the arguments.  If the resulting
   /// type would be ill-formed, return nullptr.  If the location is provided,
   /// emit detailed error messages.
   static MemRefType getImpl(ArrayRef<int64_t> shape, Type elementType,
                             ArrayRef<AffineMap> affineMapComposition,
                             unsigned memorySpace, Optional<Location> location);
   using Base::getImpl;
public:
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     Type elementType,
                                                     unsigned memorySpace);
 
   ArrayRef<int64_t> getShape() const { return llvm::None; }
 
   /// Returns the memory space in which data referred to by this memref resides.
   unsigned getMemorySpace() const;
-  static bool kindof(unsigned kind) {
-    return kind == StandardTypes::UnrankedMemRef;
-  }
 };
 
 //===----------------------------------------------------------------------===//
 // TupleType
 //===----------------------------------------------------------------------===//
 
 /// Tuple types represent a collection of other types. Note: This type merely
 /// provides a common mechanism for representing tuples in MLIR. It is up to
public:
   iterator begin() const { return getTypes().begin(); }
   iterator end() const { return getTypes().end(); }
 
   /// Return the element type at index 'index'.
   Type getType(size_t index) const {
     assert(index < size() && "invalid index for tuple type");
     return getTypes()[index];
   }
-
-  static bool kindof(unsigned kind) { return kind == StandardTypes::Tuple; }
 };
 
 //===----------------------------------------------------------------------===//
 // Type Utilities
 //===----------------------------------------------------------------------===//
 
 /// Returns the strides of the MemRef if the layout map is in strided form.
 /// MemRefs with layout maps in strided form include:

mlir/include/mlir/IR/StorageUniquerSupport.h

public:
 
   /// Utility declarations for the concrete attribute class.
   using Base = StorageUserBase<ConcreteT, BaseT, StorageT, UniquerT, Traits...>;
   using ImplType = StorageT;
 
   /// Return a unique identifier for the concrete type.
   static TypeID getTypeID() { return TypeID::get<ConcreteT>(); }
 
-  /// Provide a default implementation of 'classof' that invokes a 'kindof'
-  /// method on the concrete type.
+  /// Provide an implementation of 'classof' that compares the type id of the
+  /// provided value with that of the concerete 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());
+    return val.getTypeID() == getTypeID();
   }
 
   /// Returns an interface map for the interfaces registered to this storage
   /// user. This should not be used directly.
   static detail::InterfaceMap getInterfaceMap() {
     return detail::InterfaceMap::template get<Traits<ConcreteT>...>();
   }
 
static ConcreteT getChecked(LocationT loc, unsigned kind, Args... args) {
     // If the construction invariants fail then we return a null attribute.
     if (failed(ConcreteT::verifyConstructionInvariants(loc, args...)))
       return ConcreteT();
     return UniquerT::template get<ConcreteT>(loc.getContext(), kind, args...);
   }
 
   /// Mutate the current storage instance. This will not change the unique key.
   /// The arguments are forwarded to 'ConcreteT::mutate'.
-  template <typename... Args>
-  LogicalResult mutate(Args &&...args) {
+  template <typename... Args> LogicalResult mutate(Args &&...args) {
     return UniquerT::template mutate<ConcreteT>(this->getContext(), getImpl(),
                                                 std::forward<Args>(args)...);
   }
 
   /// Default implementation that just returns success.
   template <typename... Args>
   static LogicalResult verifyConstructionInvariants(Args... args) {
     return success();

mlir/include/mlir/IR/TypeSupport.h

 public:
   /// Look up the specified abstract type in the MLIRContext and return a
   /// reference to it.
   static const AbstractType &lookup(TypeID typeID, MLIRContext *context);
 
   /// This method is used by Dialect objects when they register the list of
   /// types they contain.
   template <typename T> static AbstractType get(Dialect &dialect) {
-    return AbstractType(dialect, T::getInterfaceMap());
+    return AbstractType(dialect, T::getInterfaceMap(), T::getTypeID());
   }
 
   /// Return the dialect this type was registered to.
   Dialect &getDialect() const { return const_cast<Dialect &>(dialect); }
 
   /// Returns an instance of the concept object for the given interface if it
   /// was registered to this type, null otherwise. This should not be used
   /// directly.
   template <typename T> typename T::Concept *getInterface() const {
     return interfaceMap.lookup<T>();
   }
 
+  /// Return the unique identifier representing the concrete type class.
+  TypeID getTypeID() const { return typeID; }
+
 private:
-  AbstractType(Dialect &dialect, detail::InterfaceMap &&interfaceMap)
-      : dialect(dialect), interfaceMap(std::move(interfaceMap)) {}
+  AbstractType(Dialect &dialect, detail::InterfaceMap &&interfaceMap,
+               TypeID typeID)
+      : dialect(dialect), interfaceMap(std::move(interfaceMap)),
+        typeID(typeID) {}
 
   /// This is the dialect that this type was registered to.
   Dialect &dialect;
 
   /// This is a collection of the interfaces registered to this type.
   detail::InterfaceMap interfaceMap;
+
+  /// The unique identifier of the derived Type class.
+  TypeID typeID;
 };
 
 //===----------------------------------------------------------------------===//
 // TypeStorage
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 struct TypeUniquer;

mlir/include/mlir/IR/Types.h

 /// different instances of the IntegerType.  Type parameters are part of the
 /// unique immutable key.  The mutable component of the type can be modified
 /// after the type is created, but cannot affect the identity of the type.
 ///
 /// Types are constructed and uniqued via the 'detail::TypeUniquer' class.
 ///
 /// Derived type classes are expected to implement several required
 /// implementation hooks:
-///  * Required:
-///    - static bool kindof(unsigned kind);
-///      * Returns if the provided type kind corresponds to an instance of the
-///        current type. Used for isa/dyn_cast casting functionality.
-///
 ///  * Optional:
 ///    - static LogicalResult verifyConstructionInvariants(Location loc,
 ///                                                        Args... args)
 ///      * This method is invoked when calling the 'TypeBase::get/getChecked'
 ///        methods to ensure that the arguments passed in are valid to construct
 ///        a type instance with.
 ///      * This method is expected to return failure if a type cannot be
 ///        constructed with 'args', success otherwise.
#include "DialectSymbolRegistry.def"
   bool isa() const;
   template <typename U> U dyn_cast() const;
   template <typename U> U dyn_cast_or_null() const;
   template <typename U> U cast() const;
 
   // Support type casting Type to itself.
   static bool classof(Type) { return true; }
 
+  /// Return a unique identifier for the concrete type. This is used to support
+  /// dynamic type casting.
+  TypeID getTypeID() { return impl->getAbstractType().getTypeID(); }
+
   /// Return the classification for this type.
   unsigned getKind() const;
 
   /// Return the LLVMContext in which this type was uniqued.
   MLIRContext *getContext() const;
 
   /// Get the dialect this type is registered to.
   Dialect &getDialect() const;
class FunctionType
     : public Type::TypeBase<FunctionType, Type, detail::FunctionTypeStorage> {
 public:
   using Base::Base;
 
   static FunctionType get(TypeRange inputs, TypeRange results,
                           MLIRContext *context);
 
   // Input types.
-<<<<<<< dest:   de5c6c6c3887 - riverriddle: [mlir] Add a utility class, Threa...
-  unsigned getNumInputs() const { return getSubclassData(); }
-||||||| base
-  unsigned getNumInputs() const { return getSubclassData(); }
-
-=======
   unsigned getNumInputs() const;
-
->>>>>>> source: f412125b3eaf - riverriddle: [mlir][Types] Remove the subclass...
   Type getInput(unsigned i) const { return getInputs()[i]; }
   ArrayRef<Type> getInputs() const;
 
   // Result types.
   unsigned getNumResults() const;
   Type getResult(unsigned i) const { return getResults()[i]; }
   ArrayRef<Type> getResults() const;
-
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool kindof(unsigned kind) { return kind == Kind::Function; }
 };
 
 //===----------------------------------------------------------------------===//
 // OpaqueType
 //===----------------------------------------------------------------------===//
 
 /// Opaque types represent types of non-registered dialects. These are types
 /// represented in their raw string form, and can only usefully be tested for
public:
 
   /// Returns the raw type data of the opaque type.
   StringRef getTypeData() const;
 
   /// Verify the construction of an opaque type.
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     Identifier dialect,
                                                     StringRef typeData);
-
-  static bool kindof(unsigned kind) { return kind == Kind::Opaque; }
 };
 
 // Make Type hashable.
 inline ::llvm::hash_code hash_value(Type arg) {
   return ::llvm::hash_value(arg.impl);
 }
 
 template <typename U> bool Type::isa() const {

mlir/include/mlir/Support/ThreadLocalCache.h

 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/ThreadLocal.h"
 
 namespace mlir {
 /// This class provides support for defining a thread local object with non
 /// static storage duration. This is very useful for situations in which a data
 /// cache has very large lock contention.
-template <typename ValueT>
-class ThreadLocalCache {
+template <typename ValueT> class ThreadLocalCache {
   /// The type used for the static thread_local cache. This is a map between an
   /// instance of the non-static cache and a nullable instance of ValueT. We use
   /// a nullable type here so that the object can be destroyed without needing
   /// to lock access to the cache itself.
   struct CacheType
       : public llvm::SmallDenseMap<ThreadLocalCache<ValueT> *,
                                    std::unique_ptr<Optional<ValueT>>> {
     ~CacheType() {

mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp

 ArrayRef<LLVMType> LLVMStructType::getBody() {
   return isIdentified() ? getImpl()->getIdentifiedStructBody()
                         : getImpl()->getTypeList();
 }
 
 //===----------------------------------------------------------------------===//
 // Vector types.
 
+/// Support type casting functionality.
+bool LLVMVectorType::classof(Type type) {
+  return type.isa<LLVMFixedVectorType, LLVMScalableVectorType>();
+}
+
 LLVMType LLVMVectorType::getElementType() {
   // Both derived classes share the implementation type.
   return static_cast<detail::LLVMTypeAndSizeStorage *>(impl)->elementType;
 }
 
 llvm::ElementCount LLVMVectorType::getElementCount() {
   // Both derived classes share the implementation type.
   return llvm::ElementCount(
       static_cast<detail::LLVMTypeAndSizeStorage *>(impl)->numElements,
-      this->isa<LLVMScalableVectorType>());
+      isa<LLVMScalableVectorType>());
 }
 
 LLVMFixedVectorType LLVMFixedVectorType::get(LLVMType elementType,
                                              unsigned numElements) {
   assert(elementType && "expected non-null subtype");
   return Base::get(elementType.getContext(), LLVMType::FixedVectorType,
                    elementType, numElements)
       .cast<LLVMFixedVectorType>();

mlir/lib/IR/MLIRContext.cpp

 // Type uniquing
 //===----------------------------------------------------------------------===//
 
 /// Returns the storage uniquer used for constructing type storage instances.
 /// This should not be used directly.
 StorageUniquer &MLIRContext::getTypeUniquer() { return getImpl().typeUniquer; }
 
 FloatType FloatType::get(StandardTypes::Kind kind, MLIRContext *context) {
-  assert(kindof(kind) && "Not a FP kind.");
   switch (kind) {
   case StandardTypes::BF16:
     return context->getImpl().bf16Ty;
   case StandardTypes::F16:
     return context->getImpl().f16Ty;
   case StandardTypes::F32:
     return context->getImpl().f32Ty;
   case StandardTypes::F64:

mlir/test/lib/Dialect/Test/TestTypes.h

 
 #include "TestTypeInterfaces.h.inc"
 
 /// This class is a simple test type that uses a generated interface.
 struct TestType : public Type::TypeBase<TestType, Type, TypeStorage,
                                         TestTypeInterface::Trait> {
   using Base::Base;
 
-  static bool kindof(unsigned kind) {
-    return kind == Type::Kind::FIRST_PRIVATE_EXPERIMENTAL_9_TYPE;
-  }
-
   static TestType get(MLIRContext *context) {
     return Base::get(context, Type::Kind::FIRST_PRIVATE_EXPERIMENTAL_9_TYPE);
   }
 
   /// Provide a definition for the necessary interface methods.
   void printTypeC(Location loc) const {
     emitRemark(loc) << *this << " - TestC";
   }

 /// Simple recursive type identified by its name and pointing to another named
 /// type, potentially itself. This requires the body to be mutated separately
 /// from type creation.
 class TestRecursiveType
     : public Type::TypeBase<TestRecursiveType, Type, TestRecursiveTypeStorage> {
 public:
   using Base::Base;
 
-  static bool kindof(unsigned kind) {
-    return kind == Type::Kind::FIRST_PRIVATE_EXPERIMENTAL_9_TYPE + 1;
-  }
-
   static TestRecursiveType create(MLIRContext *ctx, StringRef name) {
     return Base::get(ctx, Type::Kind::FIRST_PRIVATE_EXPERIMENTAL_9_TYPE + 1,
                      name);
   }
 
   /// Body getter and setter.
   LogicalResult setBody(Type body) { return Base::mutate(body); }
   Type getBody() { return getImpl()->body; }
 
   /// Name/key getter.
   StringRef getName() { return getImpl()->name; }
 };
 
 } // end namespace mlir
 
 #endif // MLIR_TESTTYPES_H