[mlir] Update method cast calls to function calls

[tpopp]

Summary

The MLIR classes Type/Attribute/Operation/Op/Value support
cast/dyn_cast/isa/dyn_cast_or_null functionality through llvm's doCast
functionality in addition to defining methods with the same name.
This change begins the migration of uses of the method to the
corresponding function call as has been decided as more consistent.

Note that there still exist classes that only define methods directly,
such as AffineExpr, and this does not include work currently to support
a functional cast/isa call.

Context:

• https://mlir.llvm.org/deprecation/ at "Use the free function variants for dyn_cast/cast/isa/…"
• Original discussion at https://discourse.llvm.org/t/preferred-casting-style-going-forward/68443

Implementation:
This follows a previous patch that updated calls
op.cast<T>()-> cast<T>(op). However some cases could not handle an
unprefixed cast call due to occurrences of variables named cast, or
occurring inside of class definitions which would resolve to the method.
All C++ files that did not work automatically with cast<T>() are
updated here to llvm::cast and similar with the intention that they
can be easily updated after the methods are removed through a
find-replace.

See https://github.com/llvm/llvm-project/compare/main...tpopp:llvm-project:tidy-cast-check
for the clang-tidy check that is used and then update printed
occurrences of the function to include llvm:: before.

One can then run the following:

ninja clang-tidy

run-clang-tidy -clang-tidy-binary=$PWD/bin/clang-tidy -checks='-*,misc-cast-functions'\
                 -export-fixes /tmp/cast/casts.yaml mlir/*

./bin/clang-apply-replacements /tmp/cast/

[tpopp]

Also refactor header files

[tpopp]

Undo some changes that were handled by parent commit.

[rriddle]

LGTM! Nice! I'd ask if you can drop the llvm:: where it isn't necessary, but that can be more easily done with the class methods themselves are removed.

[tpopp]

In D150348#4337150, @rriddle wrote:

LGTM! Nice! I'd ask if you can drop the llvm:: where it isn't necessary, but that can be more easily done with the class methods themselves are removed.

Yes, I'm being a bit less perfect in the changes with the plan of doing a find-replace-all after the methods are removed. It's not perfect, but I suspect it will save me many hours, at least with the approaches I've thought of.

mlir/include/mlir/IR/Builders.h

public:
   /// has a defining operation, sets the insertion point to the node after such
   /// defining operation. This will cause subsequent insertions to go right
   /// after it. Otherwise, value is a BlockArgument. Sets the insertion point to
   /// the start of its block.
   void setInsertionPointAfterValue(Value val) {
     if (Operation *op = val.getDefiningOp()) {
       setInsertionPointAfter(op);
     } else {
-      auto blockArg = val.cast<BlockArgument>();
+      auto blockArg = llvm::cast<BlockArgument>(val);
       setInsertionPointToStart(blockArg.getOwner());
     }
   }
 
   /// Sets the insertion point to the start of the specified block.
   void setInsertionPointToStart(Block *block) {
     setInsertionPoint(block, block->begin());
   }

mlir/include/mlir/IR/BuiltinAttributes.h

getSplatValue() const {
     return *value_begin<T>();
   }
   /// Return the splat value for derived attribute element types.
   template <typename T>
   std::enable_if_t<std::is_base_of<Attribute, T>::value &&
                        !std::is_same<Attribute, T>::value,
                    T>
   getSplatValue() const {
-    return getSplatValue<Attribute>().template cast<T>();
+    return llvm::cast<T>(getSplatValue<Attribute>());
   }
 
   /// Try to get an iterator of the given type to the start of the held element
   /// values. Return failure if the type cannot be iterated.
   template <typename T>
   auto try_value_begin() const {
     auto range = tryGetValues<T>();
     using iterator = decltype(range->begin());
public:
   struct DerivedAttributeElementIterator
       : public llvm::mapped_iterator_base<DerivedAttributeElementIterator<T>,
                                           AttributeElementIterator, T> {
     using llvm::mapped_iterator_base<DerivedAttributeElementIterator<T>,
                                      AttributeElementIterator,
                                      T>::mapped_iterator_base;
 
     /// Map the element to the iterator result type.
-    T mapElement(Attribute attr) const { return attr.cast<T>(); }
+    T mapElement(Attribute attr) const { return llvm::cast<T>(attr); }
   };
   template <typename T, typename = DerivedAttrValueTemplateCheckT<T>>
   FailureOr<iterator_range_impl<DerivedAttributeElementIterator<T>>>
   tryGetValues() const {
     using DerivedIterT = DerivedAttributeElementIterator<T>;
     return iterator_range_impl<DerivedIterT>(
         getType(), DerivedIterT(value_begin<Attribute>()),
         DerivedIterT(value_end<Attribute>()));

 /// An attribute that represents a reference to a splat vector or tensor
 /// constant, meaning all of the elements have the same value.
 class SplatElementsAttr : public DenseElementsAttr {
 public:
   using DenseElementsAttr::DenseElementsAttr;
 
   /// Method for support type inquiry through isa, cast and dyn_cast.
   static bool classof(Attribute attr) {
-    auto denseAttr = attr.dyn_cast<DenseElementsAttr>();
+    auto denseAttr = llvm::dyn_cast<DenseElementsAttr>(attr);
     return denseAttr && denseAttr.isSplat();
   }
 };
 
 //===----------------------------------------------------------------------===//
 // DenseResourceElementsAttr
 //===----------------------------------------------------------------------===//
 
public:
   /// Returns the name of the held symbol reference as a StringAttr.
   StringAttr getAttr() const { return getRootReference(); }
 
   /// Returns the name of the held symbol reference.
   StringRef getValue() const { return getAttr().getValue(); }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool classof(Attribute attr) {
-    SymbolRefAttr refAttr = attr.dyn_cast<SymbolRefAttr>();
+    SymbolRefAttr refAttr = llvm::dyn_cast<SymbolRefAttr>(attr);
     return refAttr && refAttr.getNestedReferences().empty();
   }
 
 private:
   using SymbolRefAttr::get;
   using SymbolRefAttr::getNestedReferences;
 };
 
 //===----------------------------------------------------------------------===//
 // DenseFPElementsAttr
 //===----------------------------------------------------------------------===//
 
 /// An attribute that represents a reference to a dense float vector or tensor
 /// object. Each element is stored as a double.
 class DenseFPElementsAttr : public DenseIntOrFPElementsAttr {
 public:
   using iterator = DenseElementsAttr::FloatElementIterator;
 
   using DenseIntOrFPElementsAttr::DenseIntOrFPElementsAttr;
 
   /// Get an instance of a DenseFPElementsAttr with the given arguments. This
   /// simply wraps the DenseElementsAttr::get calls.
   template <typename Arg>
   static DenseFPElementsAttr get(const ShapedType &type, Arg &&arg) {
-    return DenseElementsAttr::get(type, llvm::ArrayRef(arg))
-        .template cast<DenseFPElementsAttr>();
+    return llvm::cast<DenseFPElementsAttr>(
+        DenseElementsAttr::get(type, llvm::ArrayRef(arg)));
   }
   template <typename T>
   static DenseFPElementsAttr get(const ShapedType &type,
                                  const std::initializer_list<T> &list) {
-    return DenseElementsAttr::get(type, list)
-        .template cast<DenseFPElementsAttr>();
+    return llvm::cast<DenseFPElementsAttr>(DenseElementsAttr::get(type, list));
   }
 
   /// Generates a new DenseElementsAttr by mapping each value attribute, and
   /// constructing the DenseElementsAttr given the new element type.
   DenseElementsAttr
   mapValues(Type newElementType,
             function_ref<APInt(const APFloat &)> mapping) const;
 
public:
   using iterator = DenseElementsAttr::IntElementIterator;
 
   using DenseIntOrFPElementsAttr::DenseIntOrFPElementsAttr;
 
   /// Get an instance of a DenseIntElementsAttr with the given arguments. This
   /// simply wraps the DenseElementsAttr::get calls.
   template <typename Arg>
   static DenseIntElementsAttr get(const ShapedType &type, Arg &&arg) {
-    return DenseElementsAttr::get(type, llvm::ArrayRef(arg))
-        .template cast<DenseIntElementsAttr>();
+    return llvm::cast<DenseIntElementsAttr>(
+        DenseElementsAttr::get(type, llvm::ArrayRef(arg)));
   }
   template <typename T>
   static DenseIntElementsAttr get(const ShapedType &type,
                                   const std::initializer_list<T> &list) {
-    return DenseElementsAttr::get(type, list)
-        .template cast<DenseIntElementsAttr>();
+    return llvm::cast<DenseIntElementsAttr>(DenseElementsAttr::get(type, list));
   }
 
   /// Generates a new DenseElementsAttr by mapping each value attribute, and
   /// constructing the DenseElementsAttr given the new element type.
   DenseElementsAttr mapValues(Type newElementType,
                               function_ref<APInt(const APInt &)> mapping) const;
 
   /// Iterator access to the integer element values.

mlir/include/mlir/IR/BuiltinTypes.h

 SliceVerificationResult isRankReducedType(ShapedType originalType,
                                           ShapedType candidateReducedType);
 
 //===----------------------------------------------------------------------===//
 // Deferred Method Definitions
 //===----------------------------------------------------------------------===//
 
 inline bool BaseMemRefType::classof(Type type) {
-  return type.isa<MemRefType, UnrankedMemRefType>();
+  return llvm::isa<MemRefType, UnrankedMemRefType>(type);
 }
 
 inline bool BaseMemRefType::isValidElementType(Type type) {
   return type.isIntOrIndexOrFloat() ||
-         type.isa<ComplexType, MemRefType, VectorType, UnrankedMemRefType>() ||
-         type.isa<MemRefElementTypeInterface>();
+         llvm::isa<ComplexType, MemRefType, VectorType, UnrankedMemRefType>(
+             type) ||
+         llvm::isa<MemRefElementTypeInterface>(type);
 }
 
 inline bool FloatType::classof(Type type) {
-  return type
-      .isa<Float8E5M2Type, Float8E4M3FNType, Float8E5M2FNUZType,
-           Float8E4M3FNUZType, Float8E4M3B11FNUZType, BFloat16Type, Float16Type,
-           Float32Type, Float64Type, Float80Type, Float128Type>();
+  return llvm::isa<Float8E5M2Type, Float8E4M3FNType, Float8E5M2FNUZType,
+                   Float8E4M3FNUZType, Float8E4M3B11FNUZType, BFloat16Type,
+                   Float16Type, Float32Type, Float64Type, Float80Type,
+                   Float128Type>(type);
 }
 
 inline FloatType FloatType::getFloat8E5M2(MLIRContext *ctx) {
   return Float8E5M2Type::get(ctx);
 }
 
 inline FloatType FloatType::getFloat8E4M3FN(MLIRContext *ctx) {
   return Float8E4M3FNType::get(ctx);
inline FloatType FloatType::getF80(MLIRContext *ctx) {
   return Float80Type::get(ctx);
 }
 
 inline FloatType FloatType::getF128(MLIRContext *ctx) {
   return Float128Type::get(ctx);
 }
 
 inline bool TensorType::classof(Type type) {
-  return type.isa<RankedTensorType, UnrankedTensorType>();
+  return llvm::isa<RankedTensorType, UnrankedTensorType>(type);
 }
 
 //===----------------------------------------------------------------------===//
 // Type Utilities
 //===----------------------------------------------------------------------===//
 
 /// Returns the strides of the MemRef if the layout map is in strided form.
 /// MemRefs with a layout map in strided form include:

mlir/include/mlir/IR/FunctionInterfaces.h

if (ArrayAttr allArgAttrs = op.getAllArgAttrs()) {
     if (allArgAttrs.size() != numArgs) {
       return op.emitOpError()
              << "expects argument attribute array to have the same number of "
                 "elements as the number of function arguments, got "
              << allArgAttrs.size() << ", but expected " << numArgs;
     }
     for (unsigned i = 0; i != numArgs; ++i) {
       DictionaryAttr argAttrs =
-          allArgAttrs[i].dyn_cast_or_null<DictionaryAttr>();
+          llvm::dyn_cast_or_null<DictionaryAttr>(allArgAttrs[i]);
       if (!argAttrs) {
         return op.emitOpError() << "expects argument attribute dictionary "
                                    "to be a DictionaryAttr, but got `"
                                 << allArgAttrs[i] << "`";
       }
 
       // Verify that all of the argument attributes are dialect attributes, i.e.
       // that they contain a dialect prefix in their name.  Call the dialect, if
if (ArrayAttr allResultAttrs = op.getAllResultAttrs()) {
     if (allResultAttrs.size() != numResults) {
       return op.emitOpError()
              << "expects result attribute array to have the same number of "
                 "elements as the number of function results, got "
              << allResultAttrs.size() << ", but expected " << numResults;
     }
     for (unsigned i = 0; i != numResults; ++i) {
       DictionaryAttr resultAttrs =
-          allResultAttrs[i].dyn_cast_or_null<DictionaryAttr>();
+          llvm::dyn_cast_or_null<DictionaryAttr>(allResultAttrs[i]);
       if (!resultAttrs) {
         return op.emitOpError() << "expects result attribute dictionary "
                                    "to be a DictionaryAttr, but got `"
                                 << allResultAttrs[i] << "`";
       }
 
       // Verify that all of the result attributes are dialect attributes, i.e.
       // that they contain a dialect prefix in their name.  Call the dialect, if

mlir/include/mlir/IR/Location.h

 /// instance of the given type.
 template <typename MetadataT>
 class FusedLocWith : public FusedLoc {
 public:
   using FusedLoc::FusedLoc;
 
   /// Return the metadata associated with this fused location.
   MetadataT getMetadata() const {
-    return FusedLoc::getMetadata().template cast<MetadataT>();
+    return llvm::cast<MetadataT>(FusedLoc::getMetadata());
   }
 
   /// Support llvm style casting.
   static bool classof(Attribute attr) {
-    auto fusedLoc = attr.dyn_cast<FusedLoc>();
+    auto fusedLoc = llvm::dyn_cast<FusedLoc>(attr);
     return fusedLoc && fusedLoc.getMetadata().isa_and_nonnull<MetadataT>();
   }
 };
 
 //===----------------------------------------------------------------------===//
 // OpaqueLoc
 //===----------------------------------------------------------------------===//
 

mlir/include/mlir/IR/Matchers.h

template <
     typename = std::enable_if_t<!std::is_void<ValueType>::value>>
 struct attr_value_binder {
   ValueType *bind_value;
 
   /// Creates a matcher instance that binds the value to bv if match succeeds.
   attr_value_binder(ValueType *bv) : bind_value(bv) {}
 
   bool match(const Attribute &attr) {
-    if (auto intAttr = attr.dyn_cast<AttrClass>()) {
+    if (auto intAttr = llvm::dyn_cast<AttrClass>(attr)) {
       *bind_value = intAttr.getValue();
       return true;
     }
     return false;
   }
 };
 
 /// The matcher that matches operations that have the `ConstantLike` trait.
if (!op->hasTrait<OpTrait::ConstantLike>())
       return false;
 
     // Fold the constant to an attribute.
     SmallVector<OpFoldResult, 1> foldedOp;
     LogicalResult result = op->fold(/*operands=*/std::nullopt, foldedOp);
     (void)result;
     assert(succeeded(result) && "expected ConstantLike op to be foldable");
 
-    if (auto attr = foldedOp.front().get<Attribute>().dyn_cast<AttrT>()) {
+    if (auto attr = llvm::dyn_cast<AttrT>(foldedOp.front().get<Attribute>())) {
       if (bind_value)
         *bind_value = attr;
       return true;
     }
     return false;
   }
 };
 
struct constant_float_op_binder {
   constant_float_op_binder(FloatAttr::ValueType *bv) : bind_value(bv) {}
 
   bool match(Operation *op) {
     Attribute attr;
     if (!constant_op_binder<Attribute>(&attr).match(op))
       return false;
     auto type = op->getResult(0).getType();
 
-    if (type.isa<FloatType>())
+    if (llvm::isa<FloatType>(type))
       return attr_value_binder<FloatAttr>(bind_value).match(attr);
-    if (type.isa<VectorType, RankedTensorType>()) {
-      if (auto splatAttr = attr.dyn_cast<SplatElementsAttr>()) {
+    if (llvm::isa<VectorType, RankedTensorType>(type)) {
+      if (auto splatAttr = llvm::dyn_cast<SplatElementsAttr>(attr)) {
         return attr_value_binder<FloatAttr>(bind_value)
             .match(splatAttr.getSplatValue<Attribute>());
       }
     }
     return false;
   }
 };
 
struct constant_int_op_binder {
   constant_int_op_binder(IntegerAttr::ValueType *bv) : bind_value(bv) {}
 
   bool match(Operation *op) {
     Attribute attr;
     if (!constant_op_binder<Attribute>(&attr).match(op))
       return false;
     auto type = op->getResult(0).getType();
 
-    if (type.isa<IntegerType, IndexType>())
+    if (llvm::isa<IntegerType, IndexType>(type))
       return attr_value_binder<IntegerAttr>(bind_value).match(attr);
-    if (type.isa<VectorType, RankedTensorType>()) {
-      if (auto splatAttr = attr.dyn_cast<SplatElementsAttr>()) {
+    if (llvm::isa<VectorType, RankedTensorType>(type)) {
+      if (auto splatAttr = llvm::dyn_cast<SplatElementsAttr>(attr)) {
         return attr_value_binder<IntegerAttr>(bind_value)
             .match(splatAttr.getSplatValue<Attribute>());
       }
     }
     return false;
   }
 };
 

mlir/include/mlir/IR/OpImplementation.h

void printOptionalArrowTypeList(TypeRange &&types) {
     if (types.begin() != types.end())
       printArrowTypeList(types);
   }
   template <typename TypeRange>
   void printArrowTypeList(TypeRange &&types) {
     auto &os = getStream() << " -> ";
 
     bool wrapped = !llvm::hasSingleElement(types) ||
-                   (*types.begin()).template isa<FunctionType>();
+                   llvm::isa<FunctionType>((*types.begin()));
     if (wrapped)
       os << '(';
     llvm::interleaveComma(types, *this);
     if (wrapped)
       os << ')';
   }
 
   /// Print the two given type ranges in a functional form.
ParseResult parseAttribute(AttrType &result, Type type = {}) {
     SMLoc loc = getCurrentLocation();
 
     // Parse any kind of attribute.
     Attribute attr;
     if (parseAttribute(attr, type))
       return failure();
 
     // Check for the right kind of attribute.
-    if (!(result = attr.dyn_cast<AttrType>()))
+    if (!(result = llvm::dyn_cast<AttrType>(attr)))
       return emitError(loc, "invalid kind of attribute specified");
 
     return success();
   }
 
   /// Parse an arbitrary attribute and return it in result.  This also adds the
   /// attribute to the specified attribute list with the specified name.
   ParseResult parseAttribute(Attribute &result, StringRef attrName,
ParseResult parseAttribute(AttrType &result, Type type, StringRef attrName,
     SMLoc loc = getCurrentLocation();
 
     // Parse any kind of attribute.
     Attribute attr;
     if (parseAttribute(attr, type))
       return failure();
 
     // Check for the right kind of attribute.
-    result = attr.dyn_cast<AttrType>();
+    result = llvm::dyn_cast<AttrType>(attr);
     if (!result)
       return emitError(loc, "invalid kind of attribute specified");
 
     attrs.append(attrName, result);
     return success();
   }
 
   /// Trait to check if `AttrType` provides a `parse` method.
if (parseCustomAttributeWithFallback(
               result = AttrType::parse(*this, type);
               if (!result)
                 return failure();
               return success();
             }))
       return failure();
 
     // Check for the right kind of attribute.
-    result = attr.dyn_cast<AttrType>();
+    result = llvm::dyn_cast<AttrType>(attr);
     if (!result)
       return emitError(loc, "invalid kind of attribute specified");
 
     attrs.append(attrName, result);
     return success();
   }
 
   /// SFINAE parsing method for Attribute that don't implement a parse method.
parseCustomAttributeWithFallback(AttrType &result, Type type = {}) {
     if (parseCustomAttributeWithFallback(
             attr, type, [&](Attribute &result, Type type) -> ParseResult {
               result = AttrType::parse(*this, type);
               return success(!!result);
             }))
       return failure();
 
     // Check for the right kind of attribute.
-    result = attr.dyn_cast<AttrType>();
+    result = llvm::dyn_cast<AttrType>(attr);
     if (!result)
       return emitError(loc, "invalid kind of attribute specified");
     return success();
   }
 
   /// SFINAE parsing method for Attribute that don't implement a parse method.
   template <typename AttrType>
   std::enable_if_t<!detect_has_parse_method<AttrType>::value, ParseResult>
ParseResult parseType(TypeT &result) {
     SMLoc loc = getCurrentLocation();
 
     // Parse any kind of type.
     Type type;
     if (parseType(type))
       return failure();
 
     // Check for the right kind of type.
-    result = type.dyn_cast<TypeT>();
+    result = llvm::dyn_cast<TypeT>(type);
     if (!result)
       return emitError(loc, "invalid kind of type specified");
 
     return success();
   }
 
   /// Trait to check if `TypeT` provides a `parse` method.
   template <typename TypeT>
parseCustomTypeWithFallback(TypeT &result) {
     Type type;
     if (parseCustomTypeWithFallback(type, [&](Type &result) -> ParseResult {
           result = TypeT::parse(*this);
           return success(!!result);
         }))
       return failure();
 
     // Check for the right kind of Type.
-    result = type.dyn_cast<TypeT>();
+    result = llvm::dyn_cast<TypeT>(type);
     if (!result)
       return emitError(loc, "invalid kind of Type specified");
     return success();
   }
 
   /// SFINAE parsing method for Type that don't implement a parse method.
   template <typename TypeT>
   std::enable_if_t<!detect_type_has_parse_method<TypeT>::value, ParseResult>
ParseResult parseColonType(TypeType &result) {
     SMLoc loc = getCurrentLocation();
 
     // Parse any kind of type.
     Type type;
     if (parseColonType(type))
       return failure();
 
     // Check for the right kind of type.
-    result = type.dyn_cast<TypeType>();
+    result = llvm::dyn_cast<TypeType>(type);
     if (!result)
       return emitError(loc, "invalid kind of type specified");
 
     return success();
   }
 
   /// Parse a colon followed by a type list, which must have at least one type.
   virtual ParseResult parseColonTypeList(SmallVectorImpl<Type> &result) = 0;

mlir/include/mlir/IR/Operation.h

if (getPropertiesStorageSize()) {
       if (std::optional<Attribute> inherentAttr = getInherentAttr(name))
         return *inherentAttr;
     }
     return attrs.get(name);
   }
 
   template <typename AttrClass>
   AttrClass getAttrOfType(StringAttr name) {
-    return getAttr(name).dyn_cast_or_null<AttrClass>();
+    return llvm::dyn_cast_or_null<AttrClass>(getAttr(name));
   }
   template <typename AttrClass>
   AttrClass getAttrOfType(StringRef name) {
-    return getAttr(name).dyn_cast_or_null<AttrClass>();
+    return llvm::dyn_cast_or_null<AttrClass>(getAttr(name));
   }
 
   /// Return true if the operation has an attribute with the provided name,
   /// false otherwise.
   bool hasAttr(StringAttr name) {
     if (getPropertiesStorageSize()) {
       if (std::optional<Attribute> inherentAttr = getInherentAttr(name))
         return (bool)*inherentAttr;

mlir/include/mlir/IR/Value.h

 /// TypedValue can be null/empty
 template <typename Ty>
 struct TypedValue : Value {
   using Value::Value;
 
   static bool classof(Value value) { return llvm::isa<Ty>(value.getType()); }
 
   /// Return the known Type
-  Ty getType() { return Value::getType().template cast<Ty>(); }
+  Ty getType() { return llvm::cast<Ty>(Value::getType()); }
   void setType(Ty ty) { Value::setType(ty); }
 };
 
 } // namespace detail
 
 /// This is a value defined by a result of an operation.
 class OpResult : public Value {
 public:

mlir/lib/CAPI/IR/BuiltinAttributes.cpp

 
 MlirAttribute mlirAttributeGetNull() { return {nullptr}; }
 
 //===----------------------------------------------------------------------===//
 // Location attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsALocation(MlirAttribute attr) {
-  return unwrap(attr).isa<LocationAttr>();
+  return llvm::isa<LocationAttr>(unwrap(attr));
 }
 
 //===----------------------------------------------------------------------===//
 // Affine map attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAAffineMap(MlirAttribute attr) {
-  return unwrap(attr).isa<AffineMapAttr>();
+  return llvm::isa<AffineMapAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirAffineMapAttrGet(MlirAffineMap map) {
   return wrap(AffineMapAttr::get(unwrap(map)));
 }
 
 MlirAffineMap mlirAffineMapAttrGetValue(MlirAttribute attr) {
-  return wrap(unwrap(attr).cast<AffineMapAttr>().getValue());
+  return wrap(llvm::cast<AffineMapAttr>(unwrap(attr)).getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // Array attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAArray(MlirAttribute attr) {
-  return unwrap(attr).isa<ArrayAttr>();
+  return llvm::isa<ArrayAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirArrayAttrGet(MlirContext ctx, intptr_t numElements,
                                MlirAttribute const *elements) {
   SmallVector<Attribute, 8> attrs;
   return wrap(
       ArrayAttr::get(unwrap(ctx), unwrapList(static_cast<size_t>(numElements),
                                              elements, attrs)));
 }
 
 intptr_t mlirArrayAttrGetNumElements(MlirAttribute attr) {
-  return static_cast<intptr_t>(unwrap(attr).cast<ArrayAttr>().size());
+  return static_cast<intptr_t>(llvm::cast<ArrayAttr>(unwrap(attr)).size());
 }
 
 MlirAttribute mlirArrayAttrGetElement(MlirAttribute attr, intptr_t pos) {
-  return wrap(unwrap(attr).cast<ArrayAttr>().getValue()[pos]);
+  return wrap(llvm::cast<ArrayAttr>(unwrap(attr)).getValue()[pos]);
 }
 
 //===----------------------------------------------------------------------===//
 // Dictionary attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsADictionary(MlirAttribute attr) {
-  return unwrap(attr).isa<DictionaryAttr>();
+  return llvm::isa<DictionaryAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirDictionaryAttrGet(MlirContext ctx, intptr_t numElements,
                                     MlirNamedAttribute const *elements) {
   SmallVector<NamedAttribute, 8> attributes;
   attributes.reserve(numElements);
   for (intptr_t i = 0; i < numElements; ++i)
     attributes.emplace_back(unwrap(elements[i].name),
                             unwrap(elements[i].attribute));
   return wrap(DictionaryAttr::get(unwrap(ctx), attributes));
 }
 
 intptr_t mlirDictionaryAttrGetNumElements(MlirAttribute attr) {
-  return static_cast<intptr_t>(unwrap(attr).cast<DictionaryAttr>().size());
+  return static_cast<intptr_t>(llvm::cast<DictionaryAttr>(unwrap(attr)).size());
 }
 
 MlirNamedAttribute mlirDictionaryAttrGetElement(MlirAttribute attr,
                                                 intptr_t pos) {
   NamedAttribute attribute =
-      unwrap(attr).cast<DictionaryAttr>().getValue()[pos];
+      llvm::cast<DictionaryAttr>(unwrap(attr)).getValue()[pos];
   return {wrap(attribute.getName()), wrap(attribute.getValue())};
 }
 
 MlirAttribute mlirDictionaryAttrGetElementByName(MlirAttribute attr,
                                                  MlirStringRef name) {
-  return wrap(unwrap(attr).cast<DictionaryAttr>().get(unwrap(name)));
+  return wrap(llvm::cast<DictionaryAttr>(unwrap(attr)).get(unwrap(name)));
 }
 
 //===----------------------------------------------------------------------===//
 // Floating point attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAFloat(MlirAttribute attr) {
-  return unwrap(attr).isa<FloatAttr>();
+  return llvm::isa<FloatAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirFloatAttrDoubleGet(MlirContext ctx, MlirType type,
                                      double value) {
   return wrap(FloatAttr::get(unwrap(type), value));
 }
 
 MlirAttribute mlirFloatAttrDoubleGetChecked(MlirLocation loc, MlirType type,
                                             double value) {
   return wrap(FloatAttr::getChecked(unwrap(loc), unwrap(type), value));
 }
 
 double mlirFloatAttrGetValueDouble(MlirAttribute attr) {
-  return unwrap(attr).cast<FloatAttr>().getValueAsDouble();
+  return llvm::cast<FloatAttr>(unwrap(attr)).getValueAsDouble();
 }
 
 //===----------------------------------------------------------------------===//
 // Integer attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAInteger(MlirAttribute attr) {
-  return unwrap(attr).isa<IntegerAttr>();
+  return llvm::isa<IntegerAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirIntegerAttrGet(MlirType type, int64_t value) {
   return wrap(IntegerAttr::get(unwrap(type), value));
 }
 
 int64_t mlirIntegerAttrGetValueInt(MlirAttribute attr) {
-  return unwrap(attr).cast<IntegerAttr>().getInt();
+  return llvm::cast<IntegerAttr>(unwrap(attr)).getInt();
 }
 
 int64_t mlirIntegerAttrGetValueSInt(MlirAttribute attr) {
-  return unwrap(attr).cast<IntegerAttr>().getSInt();
+  return llvm::cast<IntegerAttr>(unwrap(attr)).getSInt();
 }
 
 uint64_t mlirIntegerAttrGetValueUInt(MlirAttribute attr) {
-  return unwrap(attr).cast<IntegerAttr>().getUInt();
+  return llvm::cast<IntegerAttr>(unwrap(attr)).getUInt();
 }
 
 //===----------------------------------------------------------------------===//
 // Bool attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsABool(MlirAttribute attr) {
-  return unwrap(attr).isa<BoolAttr>();
+  return llvm::isa<BoolAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirBoolAttrGet(MlirContext ctx, int value) {
   return wrap(BoolAttr::get(unwrap(ctx), value));
 }
 
 bool mlirBoolAttrGetValue(MlirAttribute attr) {
-  return unwrap(attr).cast<BoolAttr>().getValue();
+  return llvm::cast<BoolAttr>(unwrap(attr)).getValue();
 }
 
 //===----------------------------------------------------------------------===//
 // Integer set attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAIntegerSet(MlirAttribute attr) {
-  return unwrap(attr).isa<IntegerSetAttr>();
+  return llvm::isa<IntegerSetAttr>(unwrap(attr));
 }
 
 //===----------------------------------------------------------------------===//
 // Opaque attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAOpaque(MlirAttribute attr) {
-  return unwrap(attr).isa<OpaqueAttr>();
+  return llvm::isa<OpaqueAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirOpaqueAttrGet(MlirContext ctx, MlirStringRef dialectNamespace,
                                 intptr_t dataLength, const char *data,
                                 MlirType type) {
   return wrap(
       OpaqueAttr::get(StringAttr::get(unwrap(ctx), unwrap(dialectNamespace)),
                       StringRef(data, dataLength), unwrap(type)));
 }
 
 MlirStringRef mlirOpaqueAttrGetDialectNamespace(MlirAttribute attr) {
-  return wrap(unwrap(attr).cast<OpaqueAttr>().getDialectNamespace().strref());
+  return wrap(
+      llvm::cast<OpaqueAttr>(unwrap(attr)).getDialectNamespace().strref());
 }
 
 MlirStringRef mlirOpaqueAttrGetData(MlirAttribute attr) {
-  return wrap(unwrap(attr).cast<OpaqueAttr>().getAttrData());
+  return wrap(llvm::cast<OpaqueAttr>(unwrap(attr)).getAttrData());
 }
 
 //===----------------------------------------------------------------------===//
 // String attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAString(MlirAttribute attr) {
-  return unwrap(attr).isa<StringAttr>();
+  return llvm::isa<StringAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirStringAttrGet(MlirContext ctx, MlirStringRef str) {
   return wrap((Attribute)StringAttr::get(unwrap(ctx), unwrap(str)));
 }
 
 MlirAttribute mlirStringAttrTypedGet(MlirType type, MlirStringRef str) {
   return wrap((Attribute)StringAttr::get(unwrap(str), unwrap(type)));
 }
 
 MlirStringRef mlirStringAttrGetValue(MlirAttribute attr) {
-  return wrap(unwrap(attr).cast<StringAttr>().getValue());
+  return wrap(llvm::cast<StringAttr>(unwrap(attr)).getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolRef attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsASymbolRef(MlirAttribute attr) {
-  return unwrap(attr).isa<SymbolRefAttr>();
+  return llvm::isa<SymbolRefAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirSymbolRefAttrGet(MlirContext ctx, MlirStringRef symbol,
                                    intptr_t numReferences,
                                    MlirAttribute const *references) {
   SmallVector<FlatSymbolRefAttr, 4> refs;
   refs.reserve(numReferences);
   for (intptr_t i = 0; i < numReferences; ++i)
-    refs.push_back(unwrap(references[i]).cast<FlatSymbolRefAttr>());
+    refs.push_back(llvm::cast<FlatSymbolRefAttr>(unwrap(references[i])));
   auto symbolAttr = StringAttr::get(unwrap(ctx), unwrap(symbol));
   return wrap(SymbolRefAttr::get(symbolAttr, refs));
 }
 
 MlirStringRef mlirSymbolRefAttrGetRootReference(MlirAttribute attr) {
-  return wrap(unwrap(attr).cast<SymbolRefAttr>().getRootReference().getValue());
+  return wrap(
+      llvm::cast<SymbolRefAttr>(unwrap(attr)).getRootReference().getValue());
 }
 
 MlirStringRef mlirSymbolRefAttrGetLeafReference(MlirAttribute attr) {
-  return wrap(unwrap(attr).cast<SymbolRefAttr>().getLeafReference().getValue());
+  return wrap(
+      llvm::cast<SymbolRefAttr>(unwrap(attr)).getLeafReference().getValue());
 }
 
 intptr_t mlirSymbolRefAttrGetNumNestedReferences(MlirAttribute attr) {
   return static_cast<intptr_t>(
-      unwrap(attr).cast<SymbolRefAttr>().getNestedReferences().size());
+      llvm::cast<SymbolRefAttr>(unwrap(attr)).getNestedReferences().size());
 }
 
 MlirAttribute mlirSymbolRefAttrGetNestedReference(MlirAttribute attr,
                                                   intptr_t pos) {
-  return wrap(unwrap(attr).cast<SymbolRefAttr>().getNestedReferences()[pos]);
+  return wrap(
+      llvm::cast<SymbolRefAttr>(unwrap(attr)).getNestedReferences()[pos]);
 }
 
 //===----------------------------------------------------------------------===//
 // Flat SymbolRef attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAFlatSymbolRef(MlirAttribute attr) {
-  return unwrap(attr).isa<FlatSymbolRefAttr>();
+  return llvm::isa<FlatSymbolRefAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirFlatSymbolRefAttrGet(MlirContext ctx, MlirStringRef symbol) {
   return wrap(FlatSymbolRefAttr::get(unwrap(ctx), unwrap(symbol)));
 }
 
 MlirStringRef mlirFlatSymbolRefAttrGetValue(MlirAttribute attr) {
-  return wrap(unwrap(attr).cast<FlatSymbolRefAttr>().getValue());
+  return wrap(llvm::cast<FlatSymbolRefAttr>(unwrap(attr)).getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // Type attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAType(MlirAttribute attr) {
-  return unwrap(attr).isa<TypeAttr>();
+  return llvm::isa<TypeAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirTypeAttrGet(MlirType type) {
   return wrap(TypeAttr::get(unwrap(type)));
 }
 
 MlirType mlirTypeAttrGetValue(MlirAttribute attr) {
-  return wrap(unwrap(attr).cast<TypeAttr>().getValue());
+  return wrap(llvm::cast<TypeAttr>(unwrap(attr)).getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // Unit attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAUnit(MlirAttribute attr) {
-  return unwrap(attr).isa<UnitAttr>();
+  return llvm::isa<UnitAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirUnitAttrGet(MlirContext ctx) {
   return wrap(UnitAttr::get(unwrap(ctx)));
 }
 
 //===----------------------------------------------------------------------===//
 // Elements attributes.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAElements(MlirAttribute attr) {
-  return unwrap(attr).isa<ElementsAttr>();
+  return llvm::isa<ElementsAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirElementsAttrGetValue(MlirAttribute attr, intptr_t rank,
                                        uint64_t *idxs) {
-  return wrap(unwrap(attr)
-                  .cast<ElementsAttr>()
+  return wrap(llvm::cast<ElementsAttr>(unwrap(attr))
                   .getValues<Attribute>()[llvm::ArrayRef(idxs, rank)]);
 }
 
 bool mlirElementsAttrIsValidIndex(MlirAttribute attr, intptr_t rank,
                                   uint64_t *idxs) {
-  return unwrap(attr).cast<ElementsAttr>().isValidIndex(
-      llvm::ArrayRef(idxs, rank));
+  return llvm::cast<ElementsAttr>(unwrap(attr))
+      .isValidIndex(llvm::ArrayRef(idxs, rank));
 }
 
 int64_t mlirElementsAttrGetNumElements(MlirAttribute attr) {
-  return unwrap(attr).cast<ElementsAttr>().getNumElements();
+  return llvm::cast<ElementsAttr>(unwrap(attr)).getNumElements();
 }
 
 //===----------------------------------------------------------------------===//
 // Dense array attribute.
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // IsA support.
 
 bool mlirAttributeIsADenseBoolArray(MlirAttribute attr) {
-  return unwrap(attr).isa<DenseBoolArrayAttr>();
+  return llvm::isa<DenseBoolArrayAttr>(unwrap(attr));
 }
 bool mlirAttributeIsADenseI8Array(MlirAttribute attr) {
-  return unwrap(attr).isa<DenseI8ArrayAttr>();
+  return llvm::isa<DenseI8ArrayAttr>(unwrap(attr));
 }
 bool mlirAttributeIsADenseI16Array(MlirAttribute attr) {
-  return unwrap(attr).isa<DenseI16ArrayAttr>();
+  return llvm::isa<DenseI16ArrayAttr>(unwrap(attr));
 }
 bool mlirAttributeIsADenseI32Array(MlirAttribute attr) {
-  return unwrap(attr).isa<DenseI32ArrayAttr>();
+  return llvm::isa<DenseI32ArrayAttr>(unwrap(attr));
 }
 bool mlirAttributeIsADenseI64Array(MlirAttribute attr) {
-  return unwrap(attr).isa<DenseI64ArrayAttr>();
+  return llvm::isa<DenseI64ArrayAttr>(unwrap(attr));
 }
 bool mlirAttributeIsADenseF32Array(MlirAttribute attr) {
-  return unwrap(attr).isa<DenseF32ArrayAttr>();
+  return llvm::isa<DenseF32ArrayAttr>(unwrap(attr));
 }
 bool mlirAttributeIsADenseF64Array(MlirAttribute attr) {
-  return unwrap(attr).isa<DenseF64ArrayAttr>();
+  return llvm::isa<DenseF64ArrayAttr>(unwrap(attr));
 }
 
 //===----------------------------------------------------------------------===//
 // Constructors.
 
 MlirAttribute mlirDenseBoolArrayGet(MlirContext ctx, intptr_t size,
                                     int const *values) {
   SmallVector<bool, 4> elements(values, values + size);
MlirAttribute mlirDenseF64ArrayGet(MlirContext ctx, intptr_t size,
   return wrap(
       DenseF64ArrayAttr::get(unwrap(ctx), ArrayRef<double>(values, size)));
 }
 
 //===----------------------------------------------------------------------===//
 // Accessors.
 
 intptr_t mlirDenseArrayGetNumElements(MlirAttribute attr) {
-  return unwrap(attr).cast<DenseArrayAttr>().size();
+  return llvm::cast<DenseArrayAttr>(unwrap(attr)).size();
 }
 
 //===----------------------------------------------------------------------===//
 // Indexed accessors.
 
 bool mlirDenseBoolArrayGetElement(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseBoolArrayAttr>()[pos];
+  return llvm::cast<DenseBoolArrayAttr>(unwrap(attr))[pos];
 }
 int8_t mlirDenseI8ArrayGetElement(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseI8ArrayAttr>()[pos];
+  return llvm::cast<DenseI8ArrayAttr>(unwrap(attr))[pos];
 }
 int16_t mlirDenseI16ArrayGetElement(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseI16ArrayAttr>()[pos];
+  return llvm::cast<DenseI16ArrayAttr>(unwrap(attr))[pos];
 }
 int32_t mlirDenseI32ArrayGetElement(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseI32ArrayAttr>()[pos];
+  return llvm::cast<DenseI32ArrayAttr>(unwrap(attr))[pos];
 }
 int64_t mlirDenseI64ArrayGetElement(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseI64ArrayAttr>()[pos];
+  return llvm::cast<DenseI64ArrayAttr>(unwrap(attr))[pos];
 }
 float mlirDenseF32ArrayGetElement(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseF32ArrayAttr>()[pos];
+  return llvm::cast<DenseF32ArrayAttr>(unwrap(attr))[pos];
 }
 double mlirDenseF64ArrayGetElement(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseF64ArrayAttr>()[pos];
+  return llvm::cast<DenseF64ArrayAttr>(unwrap(attr))[pos];
 }
 
 //===----------------------------------------------------------------------===//
 // Dense elements attribute.
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // IsA support.
 
 bool mlirAttributeIsADenseElements(MlirAttribute attr) {
-  return unwrap(attr).isa<DenseElementsAttr>();
+  return llvm::isa<DenseElementsAttr>(unwrap(attr));
 }
 bool mlirAttributeIsADenseIntElements(MlirAttribute attr) {
-  return unwrap(attr).isa<DenseIntElementsAttr>();
+  return llvm::isa<DenseIntElementsAttr>(unwrap(attr));
 }
 bool mlirAttributeIsADenseFPElements(MlirAttribute attr) {
-  return unwrap(attr).isa<DenseFPElementsAttr>();
+  return llvm::isa<DenseFPElementsAttr>(unwrap(attr));
 }
 
 //===----------------------------------------------------------------------===//
 // Constructors.
 
 MlirAttribute mlirDenseElementsAttrGet(MlirType shapedType,
                                        intptr_t numElements,
                                        MlirAttribute const *elements) {
   SmallVector<Attribute, 8> attributes;
   return wrap(
-      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
+      DenseElementsAttr::get(llvm::cast<ShapedType>(unwrap(shapedType)),
                              unwrapList(numElements, elements, attributes)));
 }
 
 MlirAttribute mlirDenseElementsAttrRawBufferGet(MlirType shapedType,
                                                 size_t rawBufferSize,
                                                 const void *rawBuffer) {
-  auto shapedTypeCpp = unwrap(shapedType).cast<ShapedType>();
+  auto shapedTypeCpp = llvm::cast<ShapedType>(unwrap(shapedType));
   ArrayRef<char> rawBufferCpp(static_cast<const char *>(rawBuffer),
                               rawBufferSize);
   bool isSplat = false;
   if (!DenseElementsAttr::isValidRawBuffer(shapedTypeCpp, rawBufferCpp,
                                            isSplat))
     return mlirAttributeGetNull();
   return wrap(DenseElementsAttr::getFromRawBuffer(shapedTypeCpp, rawBufferCpp));
 }
 
 MlirAttribute mlirDenseElementsAttrSplatGet(MlirType shapedType,
                                             MlirAttribute element) {
-  return wrap(DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
+  return wrap(DenseElementsAttr::get(llvm::cast<ShapedType>(unwrap(shapedType)),
                                      unwrap(element)));
 }
 MlirAttribute mlirDenseElementsAttrBoolSplatGet(MlirType shapedType,
                                                 bool element) {
-  return wrap(
-      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+  return wrap(DenseElementsAttr::get(llvm::cast<ShapedType>(unwrap(shapedType)),
+                                     element));
 }
 MlirAttribute mlirDenseElementsAttrUInt8SplatGet(MlirType shapedType,
                                                  uint8_t element) {
-  return wrap(
-      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+  return wrap(DenseElementsAttr::get(llvm::cast<ShapedType>(unwrap(shapedType)),
+                                     element));
 }
 MlirAttribute mlirDenseElementsAttrInt8SplatGet(MlirType shapedType,
                                                 int8_t element) {
-  return wrap(
-      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+  return wrap(DenseElementsAttr::get(llvm::cast<ShapedType>(unwrap(shapedType)),
+                                     element));
 }
 MlirAttribute mlirDenseElementsAttrUInt32SplatGet(MlirType shapedType,
                                                   uint32_t element) {
-  return wrap(
-      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+  return wrap(DenseElementsAttr::get(llvm::cast<ShapedType>(unwrap(shapedType)),
+                                     element));
 }
 MlirAttribute mlirDenseElementsAttrInt32SplatGet(MlirType shapedType,
                                                  int32_t element) {
-  return wrap(
-      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+  return wrap(DenseElementsAttr::get(llvm::cast<ShapedType>(unwrap(shapedType)),
+                                     element));
 }
 MlirAttribute mlirDenseElementsAttrUInt64SplatGet(MlirType shapedType,
                                                   uint64_t element) {
-  return wrap(
-      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+  return wrap(DenseElementsAttr::get(llvm::cast<ShapedType>(unwrap(shapedType)),
+                                     element));
 }
 MlirAttribute mlirDenseElementsAttrInt64SplatGet(MlirType shapedType,
                                                  int64_t element) {
-  return wrap(
-      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+  return wrap(DenseElementsAttr::get(llvm::cast<ShapedType>(unwrap(shapedType)),
+                                     element));
 }
 MlirAttribute mlirDenseElementsAttrFloatSplatGet(MlirType shapedType,
                                                  float element) {
-  return wrap(
-      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+  return wrap(DenseElementsAttr::get(llvm::cast<ShapedType>(unwrap(shapedType)),
+                                     element));
 }
 MlirAttribute mlirDenseElementsAttrDoubleSplatGet(MlirType shapedType,
                                                   double element) {
-  return wrap(
-      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+  return wrap(DenseElementsAttr::get(llvm::cast<ShapedType>(unwrap(shapedType)),
+                                     element));
 }
 
 MlirAttribute mlirDenseElementsAttrBoolGet(MlirType shapedType,
                                            intptr_t numElements,
                                            const int *elements) {
   SmallVector<bool, 8> values(elements, elements + numElements);
-  return wrap(
-      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), values));
+  return wrap(DenseElementsAttr::get(llvm::cast<ShapedType>(unwrap(shapedType)),
+                                     values));
 }
 
 /// Creates a dense attribute with elements of the type deduced by templates.
 template <typename T>
 static MlirAttribute getDenseAttribute(MlirType shapedType,
                                        intptr_t numElements,
                                        const T *elements) {
-  return wrap(DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
+  return wrap(DenseElementsAttr::get(llvm::cast<ShapedType>(unwrap(shapedType)),
                                      llvm::ArrayRef(elements, numElements)));
 }
 
 MlirAttribute mlirDenseElementsAttrUInt8Get(MlirType shapedType,
                                             intptr_t numElements,
                                             const uint8_t *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }

 MlirAttribute mlirDenseElementsAttrStringGet(MlirType shapedType,
                                              intptr_t numElements,
                                              MlirStringRef *strs) {
   SmallVector<StringRef, 8> values;
   values.reserve(numElements);
   for (intptr_t i = 0; i < numElements; ++i)
     values.push_back(unwrap(strs[i]));
 
-  return wrap(
-      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), values));
+  return wrap(DenseElementsAttr::get(llvm::cast<ShapedType>(unwrap(shapedType)),
+                                     values));
 }
 
 MlirAttribute mlirDenseElementsAttrReshapeGet(MlirAttribute attr,
                                               MlirType shapedType) {
-  return wrap(unwrap(attr).cast<DenseElementsAttr>().reshape(
-      unwrap(shapedType).cast<ShapedType>()));
+  return wrap(llvm::cast<DenseElementsAttr>(unwrap(attr))
+                  .reshape(llvm::cast<ShapedType>(unwrap(shapedType))));
 }
 
 //===----------------------------------------------------------------------===//
 // Splat accessors.
 
 bool mlirDenseElementsAttrIsSplat(MlirAttribute attr) {
-  return unwrap(attr).cast<DenseElementsAttr>().isSplat();
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).isSplat();
 }
 
 MlirAttribute mlirDenseElementsAttrGetSplatValue(MlirAttribute attr) {
   return wrap(
-      unwrap(attr).cast<DenseElementsAttr>().getSplatValue<Attribute>());
+      llvm::cast<DenseElementsAttr>(unwrap(attr)).getSplatValue<Attribute>());
 }
 int mlirDenseElementsAttrGetBoolSplatValue(MlirAttribute attr) {
-  return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<bool>();
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getSplatValue<bool>();
 }
 int8_t mlirDenseElementsAttrGetInt8SplatValue(MlirAttribute attr) {
-  return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<int8_t>();
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getSplatValue<int8_t>();
 }
 uint8_t mlirDenseElementsAttrGetUInt8SplatValue(MlirAttribute attr) {
-  return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<uint8_t>();
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getSplatValue<uint8_t>();
 }
 int32_t mlirDenseElementsAttrGetInt32SplatValue(MlirAttribute attr) {
-  return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<int32_t>();
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getSplatValue<int32_t>();
 }
 uint32_t mlirDenseElementsAttrGetUInt32SplatValue(MlirAttribute attr) {
-  return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<uint32_t>();
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getSplatValue<uint32_t>();
 }
 int64_t mlirDenseElementsAttrGetInt64SplatValue(MlirAttribute attr) {
-  return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<int64_t>();
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getSplatValue<int64_t>();
 }
 uint64_t mlirDenseElementsAttrGetUInt64SplatValue(MlirAttribute attr) {
-  return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<uint64_t>();
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getSplatValue<uint64_t>();
 }
 float mlirDenseElementsAttrGetFloatSplatValue(MlirAttribute attr) {
-  return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<float>();
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getSplatValue<float>();
 }
 double mlirDenseElementsAttrGetDoubleSplatValue(MlirAttribute attr) {
-  return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<double>();
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getSplatValue<double>();
 }
 MlirStringRef mlirDenseElementsAttrGetStringSplatValue(MlirAttribute attr) {
   return wrap(
-      unwrap(attr).cast<DenseElementsAttr>().getSplatValue<StringRef>());
+      llvm::cast<DenseElementsAttr>(unwrap(attr)).getSplatValue<StringRef>());
 }
 
 //===----------------------------------------------------------------------===//
 // Indexed accessors.
 
 bool mlirDenseElementsAttrGetBoolValue(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getValues<bool>()[pos];
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getValues<bool>()[pos];
 }
 int8_t mlirDenseElementsAttrGetInt8Value(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getValues<int8_t>()[pos];
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getValues<int8_t>()[pos];
 }
 uint8_t mlirDenseElementsAttrGetUInt8Value(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getValues<uint8_t>()[pos];
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getValues<uint8_t>()[pos];
 }
 int16_t mlirDenseElementsAttrGetInt16Value(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getValues<int16_t>()[pos];
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getValues<int16_t>()[pos];
 }
 uint16_t mlirDenseElementsAttrGetUInt16Value(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getValues<uint16_t>()[pos];
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getValues<uint16_t>()[pos];
 }
 int32_t mlirDenseElementsAttrGetInt32Value(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getValues<int32_t>()[pos];
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getValues<int32_t>()[pos];
 }
 uint32_t mlirDenseElementsAttrGetUInt32Value(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getValues<uint32_t>()[pos];
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getValues<uint32_t>()[pos];
 }
 int64_t mlirDenseElementsAttrGetInt64Value(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getValues<int64_t>()[pos];
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getValues<int64_t>()[pos];
 }
 uint64_t mlirDenseElementsAttrGetUInt64Value(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getValues<uint64_t>()[pos];
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getValues<uint64_t>()[pos];
 }
 float mlirDenseElementsAttrGetFloatValue(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getValues<float>()[pos];
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getValues<float>()[pos];
 }
 double mlirDenseElementsAttrGetDoubleValue(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getValues<double>()[pos];
+  return llvm::cast<DenseElementsAttr>(unwrap(attr)).getValues<double>()[pos];
 }
 MlirStringRef mlirDenseElementsAttrGetStringValue(MlirAttribute attr,
                                                   intptr_t pos) {
   return wrap(
-      unwrap(attr).cast<DenseElementsAttr>().getValues<StringRef>()[pos]);
+      llvm::cast<DenseElementsAttr>(unwrap(attr)).getValues<StringRef>()[pos]);
 }
 
 //===----------------------------------------------------------------------===//
 // Raw data accessors.
 
 const void *mlirDenseElementsAttrGetRawData(MlirAttribute attr) {
   return static_cast<const void *>(
-      unwrap(attr).cast<DenseElementsAttr>().getRawData().data());
+      llvm::cast<DenseElementsAttr>(unwrap(attr)).getRawData().data());
 }
 
 //===----------------------------------------------------------------------===//
 // Resource blob attributes.
 //===----------------------------------------------------------------------===//
 
 template <typename U, typename T>
 static MlirAttribute getDenseResource(MlirType shapedType, MlirStringRef name,
                                       intptr_t numElements, const T *elements) {
-  return wrap(U::get(unwrap(shapedType).cast<ShapedType>(), unwrap(name),
+  return wrap(U::get(llvm::cast<ShapedType>(unwrap(shapedType)), unwrap(name),
                      UnmanagedAsmResourceBlob::allocateInferAlign(
                          llvm::ArrayRef(elements, numElements))));
 }
 
 MLIR_CAPI_EXPORTED MlirAttribute mlirUnmanagedDenseBoolResourceElementsAttrGet(
     MlirType shapedType, MlirStringRef name, intptr_t numElements,
     const int *elements) {
   return getDenseResource<DenseBoolResourceElementsAttr>(shapedType, name,
mlirUnmanagedDenseDoubleResourceElementsAttrGet(MlirType shapedType,
                                                 intptr_t numElements,
                                                 const double *elements) {
   return getDenseResource<DenseF64ResourceElementsAttr>(shapedType, name,
                                                         numElements, elements);
 }
 
 template <typename U, typename T>
 static T getDenseResourceVal(MlirAttribute attr, intptr_t pos) {
-  return (*unwrap(attr).cast<U>().tryGetAsArrayRef())[pos];
+  return (*llvm::cast<U>(unwrap(attr)).tryGetAsArrayRef())[pos];
 }
 
 MLIR_CAPI_EXPORTED bool
 mlirDenseBoolResourceElementsAttrGetValue(MlirAttribute attr, intptr_t pos) {
   return getDenseResourceVal<DenseBoolResourceElementsAttr, uint8_t>(attr, pos);
 }
 MLIR_CAPI_EXPORTED uint8_t
 mlirDenseUInt8ResourceElementsAttrGetValue(MlirAttribute attr, intptr_t pos) {
mlirDenseDoubleResourceElementsAttrGetValue(MlirAttribute attr, intptr_t pos) {
   return getDenseResourceVal<DenseF64ResourceElementsAttr, double>(attr, pos);
 }
 
 //===----------------------------------------------------------------------===//
 // Sparse elements attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsASparseElements(MlirAttribute attr) {
-  return unwrap(attr).isa<SparseElementsAttr>();
+  return llvm::isa<SparseElementsAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirSparseElementsAttribute(MlirType shapedType,
                                           MlirAttribute denseIndices,
                                           MlirAttribute denseValues) {
-  return wrap(
-      SparseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
-                              unwrap(denseIndices).cast<DenseElementsAttr>(),
-                              unwrap(denseValues).cast<DenseElementsAttr>()));
+  return wrap(SparseElementsAttr::get(
+      llvm::cast<ShapedType>(unwrap(shapedType)),
+      llvm::cast<DenseElementsAttr>(unwrap(denseIndices)),
+      llvm::cast<DenseElementsAttr>(unwrap(denseValues))));
 }
 
 MlirAttribute mlirSparseElementsAttrGetIndices(MlirAttribute attr) {
-  return wrap(unwrap(attr).cast<SparseElementsAttr>().getIndices());
+  return wrap(llvm::cast<SparseElementsAttr>(unwrap(attr)).getIndices());
 }
 
 MlirAttribute mlirSparseElementsAttrGetValues(MlirAttribute attr) {
-  return wrap(unwrap(attr).cast<SparseElementsAttr>().getValues());
+  return wrap(llvm::cast<SparseElementsAttr>(unwrap(attr)).getValues());
 }
 
 //===----------------------------------------------------------------------===//
 // Strided layout attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAStridedLayout(MlirAttribute attr) {
-  return unwrap(attr).isa<StridedLayoutAttr>();
+  return llvm::isa<StridedLayoutAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirStridedLayoutAttrGet(MlirContext ctx, int64_t offset,
                                        intptr_t numStrides,
                                        const int64_t *strides) {
   return wrap(StridedLayoutAttr::get(unwrap(ctx), offset,
                                      ArrayRef<int64_t>(strides, numStrides)));
 }
 
 int64_t mlirStridedLayoutAttrGetOffset(MlirAttribute attr) {
-  return unwrap(attr).cast<StridedLayoutAttr>().getOffset();
+  return llvm::cast<StridedLayoutAttr>(unwrap(attr)).getOffset();
 }
 
 intptr_t mlirStridedLayoutAttrGetNumStrides(MlirAttribute attr) {
   return static_cast<intptr_t>(
-      unwrap(attr).cast<StridedLayoutAttr>().getStrides().size());
+      llvm::cast<StridedLayoutAttr>(unwrap(attr)).getStrides().size());
 }
 
 int64_t mlirStridedLayoutAttrGetStride(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<StridedLayoutAttr>().getStrides()[pos];
+  return llvm::cast<StridedLayoutAttr>(unwrap(attr)).getStrides()[pos];
 }

mlir/lib/CAPI/IR/BuiltinTypes.cpp

 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Integer types.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsAInteger(MlirType type) {
-  return unwrap(type).isa<IntegerType>();
+  return llvm::isa<IntegerType>(unwrap(type));
 }
 
 MlirType mlirIntegerTypeGet(MlirContext ctx, unsigned bitwidth) {
   return wrap(IntegerType::get(unwrap(ctx), bitwidth));
 }
 
 MlirType mlirIntegerTypeSignedGet(MlirContext ctx, unsigned bitwidth) {
   return wrap(IntegerType::get(unwrap(ctx), bitwidth, IntegerType::Signed));
 }
 
 MlirType mlirIntegerTypeUnsignedGet(MlirContext ctx, unsigned bitwidth) {
   return wrap(IntegerType::get(unwrap(ctx), bitwidth, IntegerType::Unsigned));
 }
 
 unsigned mlirIntegerTypeGetWidth(MlirType type) {
-  return unwrap(type).cast<IntegerType>().getWidth();
+  return llvm::cast<IntegerType>(unwrap(type)).getWidth();
 }
 
 bool mlirIntegerTypeIsSignless(MlirType type) {
-  return unwrap(type).cast<IntegerType>().isSignless();
+  return llvm::cast<IntegerType>(unwrap(type)).isSignless();
 }
 
 bool mlirIntegerTypeIsSigned(MlirType type) {
-  return unwrap(type).cast<IntegerType>().isSigned();
+  return llvm::cast<IntegerType>(unwrap(type)).isSigned();
 }
 
 bool mlirIntegerTypeIsUnsigned(MlirType type) {
-  return unwrap(type).cast<IntegerType>().isUnsigned();
+  return llvm::cast<IntegerType>(unwrap(type)).isUnsigned();
 }
 
 //===----------------------------------------------------------------------===//
 // Index type.
 //===----------------------------------------------------------------------===//
 
-bool mlirTypeIsAIndex(MlirType type) { return unwrap(type).isa<IndexType>(); }
+bool mlirTypeIsAIndex(MlirType type) {
+  return llvm::isa<IndexType>(unwrap(type));
+}
 
 MlirType mlirIndexTypeGet(MlirContext ctx) {
   return wrap(IndexType::get(unwrap(ctx)));
 }
 
 //===----------------------------------------------------------------------===//
 // Floating-point types.
 //===----------------------------------------------------------------------===//

 MlirType mlirF64TypeGet(MlirContext ctx) {
   return wrap(FloatType::getF64(unwrap(ctx)));
 }
 
 //===----------------------------------------------------------------------===//
 // None type.
 //===----------------------------------------------------------------------===//
 
-bool mlirTypeIsANone(MlirType type) { return unwrap(type).isa<NoneType>(); }
+bool mlirTypeIsANone(MlirType type) {
+  return llvm::isa<NoneType>(unwrap(type));
+}
 
 MlirType mlirNoneTypeGet(MlirContext ctx) {
   return wrap(NoneType::get(unwrap(ctx)));
 }
 
 //===----------------------------------------------------------------------===//
 // Complex type.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsAComplex(MlirType type) {
-  return unwrap(type).isa<ComplexType>();
+  return llvm::isa<ComplexType>(unwrap(type));
 }
 
 MlirType mlirComplexTypeGet(MlirType elementType) {
   return wrap(ComplexType::get(unwrap(elementType)));
 }
 
 MlirType mlirComplexTypeGetElementType(MlirType type) {
-  return wrap(unwrap(type).cast<ComplexType>().getElementType());
+  return wrap(llvm::cast<ComplexType>(unwrap(type)).getElementType());
 }
 
 //===----------------------------------------------------------------------===//
 // Shaped type.
 //===----------------------------------------------------------------------===//
 
-bool mlirTypeIsAShaped(MlirType type) { return unwrap(type).isa<ShapedType>(); }
+bool mlirTypeIsAShaped(MlirType type) {
+  return llvm::isa<ShapedType>(unwrap(type));
+}
 
 MlirType mlirShapedTypeGetElementType(MlirType type) {
-  return wrap(unwrap(type).cast<ShapedType>().getElementType());
+  return wrap(llvm::cast<ShapedType>(unwrap(type)).getElementType());
 }
 
 bool mlirShapedTypeHasRank(MlirType type) {
-  return unwrap(type).cast<ShapedType>().hasRank();
+  return llvm::cast<ShapedType>(unwrap(type)).hasRank();
 }
 
 int64_t mlirShapedTypeGetRank(MlirType type) {
-  return unwrap(type).cast<ShapedType>().getRank();
+  return llvm::cast<ShapedType>(unwrap(type)).getRank();
 }
 
 bool mlirShapedTypeHasStaticShape(MlirType type) {
-  return unwrap(type).cast<ShapedType>().hasStaticShape();
+  return llvm::cast<ShapedType>(unwrap(type)).hasStaticShape();
 }
 
 bool mlirShapedTypeIsDynamicDim(MlirType type, intptr_t dim) {
-  return unwrap(type).cast<ShapedType>().isDynamicDim(
-      static_cast<unsigned>(dim));
+  return llvm::cast<ShapedType>(unwrap(type))
+      .isDynamicDim(static_cast<unsigned>(dim));
 }
 
 int64_t mlirShapedTypeGetDimSize(MlirType type, intptr_t dim) {
-  return unwrap(type).cast<ShapedType>().getDimSize(static_cast<unsigned>(dim));
+  return llvm::cast<ShapedType>(unwrap(type))
+      .getDimSize(static_cast<unsigned>(dim));
 }
 
 int64_t mlirShapedTypeGetDynamicSize() { return ShapedType::kDynamic; }
 
 bool mlirShapedTypeIsDynamicSize(int64_t size) {
   return ShapedType::isDynamic(size);
 }
 
 bool mlirShapedTypeIsDynamicStrideOrOffset(int64_t val) {
   return ShapedType::isDynamic(val);
 }
 
 int64_t mlirShapedTypeGetDynamicStrideOrOffset() {
   return ShapedType::kDynamic;
 }
 
 //===----------------------------------------------------------------------===//
 // Vector type.
 //===----------------------------------------------------------------------===//
 
-bool mlirTypeIsAVector(MlirType type) { return unwrap(type).isa<VectorType>(); }
+bool mlirTypeIsAVector(MlirType type) {
+  return llvm::isa<VectorType>(unwrap(type));
+}
 
 MlirType mlirVectorTypeGet(intptr_t rank, const int64_t *shape,
                            MlirType elementType) {
   return wrap(VectorType::get(llvm::ArrayRef(shape, static_cast<size_t>(rank)),
                               unwrap(elementType)));
 }
 
 MlirType mlirVectorTypeGetChecked(MlirLocation loc, intptr_t rank,
                                   const int64_t *shape, MlirType elementType) {
   return wrap(VectorType::getChecked(
       unwrap(loc), llvm::ArrayRef(shape, static_cast<size_t>(rank)),
       unwrap(elementType)));
 }
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked tensor type.
 //===----------------------------------------------------------------------===//
 
-bool mlirTypeIsATensor(MlirType type) { return unwrap(type).isa<TensorType>(); }
+bool mlirTypeIsATensor(MlirType type) {
+  return llvm::isa<TensorType>(unwrap(type));
+}
 
 bool mlirTypeIsARankedTensor(MlirType type) {
-  return unwrap(type).isa<RankedTensorType>();
+  return llvm::isa<RankedTensorType>(unwrap(type));
 }
 
 bool mlirTypeIsAUnrankedTensor(MlirType type) {
-  return unwrap(type).isa<UnrankedTensorType>();
+  return llvm::isa<UnrankedTensorType>(unwrap(type));
 }
 
 MlirType mlirRankedTensorTypeGet(intptr_t rank, const int64_t *shape,
                                  MlirType elementType, MlirAttribute encoding) {
   return wrap(
       RankedTensorType::get(llvm::ArrayRef(shape, static_cast<size_t>(rank)),
                             unwrap(elementType), unwrap(encoding)));
 }
 
 MlirType mlirRankedTensorTypeGetChecked(MlirLocation loc, intptr_t rank,
                                         const int64_t *shape,
                                         MlirType elementType,
                                         MlirAttribute encoding) {
   return wrap(RankedTensorType::getChecked(
       unwrap(loc), llvm::ArrayRef(shape, static_cast<size_t>(rank)),
       unwrap(elementType), unwrap(encoding)));
 }
 
 MlirAttribute mlirRankedTensorTypeGetEncoding(MlirType type) {
-  return wrap(unwrap(type).cast<RankedTensorType>().getEncoding());
+  return wrap(llvm::cast<RankedTensorType>(unwrap(type)).getEncoding());
 }
 
 MlirType mlirUnrankedTensorTypeGet(MlirType elementType) {
   return wrap(UnrankedTensorType::get(unwrap(elementType)));
 }
 
 MlirType mlirUnrankedTensorTypeGetChecked(MlirLocation loc,
                                           MlirType elementType) {
   return wrap(UnrankedTensorType::getChecked(unwrap(loc), unwrap(elementType)));
 }
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked MemRef type.
 //===----------------------------------------------------------------------===//
 
-bool mlirTypeIsAMemRef(MlirType type) { return unwrap(type).isa<MemRefType>(); }
+bool mlirTypeIsAMemRef(MlirType type) {
+  return llvm::isa<MemRefType>(unwrap(type));
+}
 
 MlirType mlirMemRefTypeGet(MlirType elementType, intptr_t rank,
                            const int64_t *shape, MlirAttribute layout,
                            MlirAttribute memorySpace) {
   return wrap(MemRefType::get(
       llvm::ArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType),
       mlirAttributeIsNull(layout)
           ? MemRefLayoutAttrInterface()
-          : unwrap(layout).cast<MemRefLayoutAttrInterface>(),
+          : llvm::cast<MemRefLayoutAttrInterface>(unwrap(layout)),
       unwrap(memorySpace)));
 }
 
 MlirType mlirMemRefTypeGetChecked(MlirLocation loc, MlirType elementType,
                                   intptr_t rank, const int64_t *shape,
                                   MlirAttribute layout,
                                   MlirAttribute memorySpace) {
   return wrap(MemRefType::getChecked(
       unwrap(loc), llvm::ArrayRef(shape, static_cast<size_t>(rank)),
       unwrap(elementType),
       mlirAttributeIsNull(layout)
           ? MemRefLayoutAttrInterface()
-          : unwrap(layout).cast<MemRefLayoutAttrInterface>(),
+          : llvm::cast<MemRefLayoutAttrInterface>(unwrap(layout)),
       unwrap(memorySpace)));
 }
 
 MlirType mlirMemRefTypeContiguousGet(MlirType elementType, intptr_t rank,
                                      const int64_t *shape,
                                      MlirAttribute memorySpace) {
   return wrap(MemRefType::get(llvm::ArrayRef(shape, static_cast<size_t>(rank)),
                               unwrap(elementType), MemRefLayoutAttrInterface(),
                               unwrap(memorySpace)));
 }
 
 MlirType mlirMemRefTypeContiguousGetChecked(MlirLocation loc,
                                             MlirType elementType, intptr_t rank,
                                             const int64_t *shape,
                                             MlirAttribute memorySpace) {
   return wrap(MemRefType::getChecked(
       unwrap(loc), llvm::ArrayRef(shape, static_cast<size_t>(rank)),
       unwrap(elementType), MemRefLayoutAttrInterface(), unwrap(memorySpace)));
 }
 
 MlirAttribute mlirMemRefTypeGetLayout(MlirType type) {
-  return wrap(unwrap(type).cast<MemRefType>().getLayout());
+  return wrap(llvm::cast<MemRefType>(unwrap(type)).getLayout());
 }
 
 MlirAffineMap mlirMemRefTypeGetAffineMap(MlirType type) {
-  return wrap(unwrap(type).cast<MemRefType>().getLayout().getAffineMap());
+  return wrap(llvm::cast<MemRefType>(unwrap(type)).getLayout().getAffineMap());
 }
 
 MlirAttribute mlirMemRefTypeGetMemorySpace(MlirType type) {
-  return wrap(unwrap(type).cast<MemRefType>().getMemorySpace());
+  return wrap(llvm::cast<MemRefType>(unwrap(type)).getMemorySpace());
 }
 
 bool mlirTypeIsAUnrankedMemRef(MlirType type) {
-  return unwrap(type).isa<UnrankedMemRefType>();
+  return llvm::isa<UnrankedMemRefType>(unwrap(type));
 }
 
 MlirType mlirUnrankedMemRefTypeGet(MlirType elementType,
                                    MlirAttribute memorySpace) {
   return wrap(
       UnrankedMemRefType::get(unwrap(elementType), unwrap(memorySpace)));
 }
 
 MlirType mlirUnrankedMemRefTypeGetChecked(MlirLocation loc,
                                           MlirType elementType,
                                           MlirAttribute memorySpace) {
   return wrap(UnrankedMemRefType::getChecked(unwrap(loc), unwrap(elementType),
                                              unwrap(memorySpace)));
 }
 
 MlirAttribute mlirUnrankedMemrefGetMemorySpace(MlirType type) {
-  return wrap(unwrap(type).cast<UnrankedMemRefType>().getMemorySpace());
+  return wrap(llvm::cast<UnrankedMemRefType>(unwrap(type)).getMemorySpace());
 }
 
 //===----------------------------------------------------------------------===//
 // Tuple type.
 //===----------------------------------------------------------------------===//
 
-bool mlirTypeIsATuple(MlirType type) { return unwrap(type).isa<TupleType>(); }
+bool mlirTypeIsATuple(MlirType type) {
+  return llvm::isa<TupleType>(unwrap(type));
+}
 
 MlirType mlirTupleTypeGet(MlirContext ctx, intptr_t numElements,
                           MlirType const *elements) {
   SmallVector<Type, 4> types;
   ArrayRef<Type> typeRef = unwrapList(numElements, elements, types);
   return wrap(TupleType::get(unwrap(ctx), typeRef));
 }
 
 intptr_t mlirTupleTypeGetNumTypes(MlirType type) {
-  return unwrap(type).cast<TupleType>().size();
+  return llvm::cast<TupleType>(unwrap(type)).size();
 }
 
 MlirType mlirTupleTypeGetType(MlirType type, intptr_t pos) {
-  return wrap(unwrap(type).cast<TupleType>().getType(static_cast<size_t>(pos)));
+  return wrap(
+      llvm::cast<TupleType>(unwrap(type)).getType(static_cast<size_t>(pos)));
 }
 
 //===----------------------------------------------------------------------===//
 // Function type.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsAFunction(MlirType type) {
-  return unwrap(type).isa<FunctionType>();
+  return llvm::isa<FunctionType>(unwrap(type));
 }
 
 MlirType mlirFunctionTypeGet(MlirContext ctx, intptr_t numInputs,
                              MlirType const *inputs, intptr_t numResults,
                              MlirType const *results) {
   SmallVector<Type, 4> inputsList;
   SmallVector<Type, 4> resultsList;
   (void)unwrapList(numInputs, inputs, inputsList);
   (void)unwrapList(numResults, results, resultsList);
   return wrap(FunctionType::get(unwrap(ctx), inputsList, resultsList));
 }
 
 intptr_t mlirFunctionTypeGetNumInputs(MlirType type) {
-  return unwrap(type).cast<FunctionType>().getNumInputs();
+  return llvm::cast<FunctionType>(unwrap(type)).getNumInputs();
 }
 
 intptr_t mlirFunctionTypeGetNumResults(MlirType type) {
-  return unwrap(type).cast<FunctionType>().getNumResults();
+  return llvm::cast<FunctionType>(unwrap(type)).getNumResults();
 }
 
 MlirType mlirFunctionTypeGetInput(MlirType type, intptr_t pos) {
   assert(pos >= 0 && "pos in array must be positive");
-  return wrap(
-      unwrap(type).cast<FunctionType>().getInput(static_cast<unsigned>(pos)));
+  return wrap(llvm::cast<FunctionType>(unwrap(type))
+                  .getInput(static_cast<unsigned>(pos)));
 }
 
 MlirType mlirFunctionTypeGetResult(MlirType type, intptr_t pos) {
   assert(pos >= 0 && "pos in array must be positive");
-  return wrap(
-      unwrap(type).cast<FunctionType>().getResult(static_cast<unsigned>(pos)));
+  return wrap(llvm::cast<FunctionType>(unwrap(type))
+                  .getResult(static_cast<unsigned>(pos)));
 }
 
 //===----------------------------------------------------------------------===//
 // Opaque type.
 //===----------------------------------------------------------------------===//
 
-bool mlirTypeIsAOpaque(MlirType type) { return unwrap(type).isa<OpaqueType>(); }
+bool mlirTypeIsAOpaque(MlirType type) {
+  return llvm::isa<OpaqueType>(unwrap(type));
+}
 
 MlirType mlirOpaqueTypeGet(MlirContext ctx, MlirStringRef dialectNamespace,
                            MlirStringRef typeData) {
   return wrap(
       OpaqueType::get(StringAttr::get(unwrap(ctx), unwrap(dialectNamespace)),
                       unwrap(typeData)));
 }
 
 MlirStringRef mlirOpaqueTypeGetDialectNamespace(MlirType type) {
-  return wrap(unwrap(type).cast<OpaqueType>().getDialectNamespace().strref());
+  return wrap(
+      llvm::cast<OpaqueType>(unwrap(type)).getDialectNamespace().strref());
 }
 
 MlirStringRef mlirOpaqueTypeGetData(MlirType type) {
-  return wrap(unwrap(type).cast<OpaqueType>().getTypeData());
+  return wrap(llvm::cast<OpaqueType>(unwrap(type)).getTypeData());
 }

mlir/lib/CAPI/IR/IR.cpp

 // Location API.
 //===----------------------------------------------------------------------===//
 
 MlirAttribute mlirLocationGetAttribute(MlirLocation location) {
   return wrap(LocationAttr(unwrap(location)));
 }
 
 MlirLocation mlirLocationFromAttribute(MlirAttribute attribute) {
-  return wrap(Location(unwrap(attribute).cast<LocationAttr>()));
+  return wrap(Location(llvm::cast<LocationAttr>(unwrap(attribute))));
 }
 
 MlirLocation mlirLocationFileLineColGet(MlirContext context,
                                         MlirStringRef filename, unsigned line,
                                         unsigned col) {
   return wrap(Location(
       FileLineColLoc::get(unwrap(context), unwrap(filename), line, col)));
 }

 // Value API.
 //===----------------------------------------------------------------------===//
 
 bool mlirValueEqual(MlirValue value1, MlirValue value2) {
   return unwrap(value1) == unwrap(value2);
 }
 
 bool mlirValueIsABlockArgument(MlirValue value) {
-  return unwrap(value).isa<BlockArgument>();
+  return llvm::isa<BlockArgument>(unwrap(value));
 }
 
 bool mlirValueIsAOpResult(MlirValue value) {
-  return unwrap(value).isa<OpResult>();
+  return llvm::isa<OpResult>(unwrap(value));
 }
 
 MlirBlock mlirBlockArgumentGetOwner(MlirValue value) {
-  return wrap(unwrap(value).cast<BlockArgument>().getOwner());
+  return wrap(llvm::cast<BlockArgument>(unwrap(value)).getOwner());
 }
 
 intptr_t mlirBlockArgumentGetArgNumber(MlirValue value) {
   return static_cast<intptr_t>(
-      unwrap(value).cast<BlockArgument>().getArgNumber());
+      llvm::cast<BlockArgument>(unwrap(value)).getArgNumber());
 }
 
 void mlirBlockArgumentSetType(MlirValue value, MlirType type) {
-  unwrap(value).cast<BlockArgument>().setType(unwrap(type));
+  llvm::cast<BlockArgument>(unwrap(value)).setType(unwrap(type));
 }
 
 MlirOperation mlirOpResultGetOwner(MlirValue value) {
-  return wrap(unwrap(value).cast<OpResult>().getOwner());
+  return wrap(llvm::cast<OpResult>(unwrap(value)).getOwner());
 }
 
 intptr_t mlirOpResultGetResultNumber(MlirValue value) {
   return static_cast<intptr_t>(
-      unwrap(value).cast<OpResult>().getResultNumber());
+      llvm::cast<OpResult>(unwrap(value)).getResultNumber());
 }
 
 MlirType mlirValueGetType(MlirValue value) {
   return wrap(unwrap(value).getType());
 }
 
 void mlirValueDump(MlirValue value) { unwrap(value).dump(); }
 

 }
 
 MlirContext mlirAttributeGetContext(MlirAttribute attribute) {
   return wrap(unwrap(attribute).getContext());
 }
 
 MlirType mlirAttributeGetType(MlirAttribute attribute) {
   Attribute attr = unwrap(attribute);
-  if (auto typedAttr = attr.dyn_cast<TypedAttr>())
+  if (auto typedAttr = llvm::dyn_cast<TypedAttr>(attr))
     return wrap(typedAttr.getType());
   return wrap(NoneType::get(attr.getContext()));
 }
 
 MlirTypeID mlirAttributeGetTypeID(MlirAttribute attr) {
   return wrap(unwrap(attr).getTypeID());
 }
 

mlir/lib/Dialect/AMDGPU/IR/AMDGPUDialect.cpp

#include "mlir/Dialect/AMDGPU/IR/AMDGPUAttributes.cpp.inc"
       >();
 }
 
 //===----------------------------------------------------------------------===//
 // RawBuffer*Op
 //===----------------------------------------------------------------------===//
 template <typename T>
 static LogicalResult verifyRawBufferOp(T &op) {
-  MemRefType bufferType = op.getMemref().getType().template cast<MemRefType>();
+  MemRefType bufferType = llvm::cast<MemRefType>(op.getMemref().getType());
   Attribute memorySpace = bufferType.getMemorySpace();
   bool isGlobal = false;
   if (!memorySpace)
     isGlobal = true;
-  else if (auto intMemorySpace = memorySpace.dyn_cast<IntegerAttr>())
+  else if (auto intMemorySpace = llvm::dyn_cast<IntegerAttr>(memorySpace))
     isGlobal = intMemorySpace.getInt() == 0 || intMemorySpace.getInt() == 1;
-  else if (auto gpuMemorySpace = memorySpace.dyn_cast<gpu::AddressSpaceAttr>())
+  else if (auto gpuMemorySpace =
+               llvm::dyn_cast<gpu::AddressSpaceAttr>(memorySpace))
     isGlobal = gpuMemorySpace.getValue() == gpu::AddressSpace::Global;
 
   if (!isGlobal)
     return op.emitOpError(
         "Buffer ops must operate on a memref in global memory");
   if (!bufferType.hasRank())
     return op.emitOpError(
         "Cannot meaningfully buffer_store to an unranked memref");
LogicalResult MFMAOp::verify() {
   constexpr uint32_t waveSize = 64;
   Builder b(getContext());
 
   Type sourceType = getSourceA().getType();
   Type destType = getDestC().getType();
 
   Type sourceElem = sourceType, destElem = destType;
   uint32_t sourceLen = 1, destLen = 1;
-  if (auto sourceVector = sourceType.dyn_cast<VectorType>()) {
+  if (auto sourceVector = llvm::dyn_cast<VectorType>(sourceType)) {
     sourceLen = sourceVector.getNumElements();
     sourceElem = sourceVector.getElementType();
   }
-  if (auto destVector = destType.dyn_cast<VectorType>()) {
+  if (auto destVector = llvm::dyn_cast<VectorType>(destType)) {
     destLen = destVector.getNumElements();
     destElem = destVector.getElementType();
   }
 
   Type sourceBType = getSourceB().getType();
   if (sourceElem.isFloat8E5M2FNUZ() || sourceElem.isFloat8E4M3FNUZ()) {
     int64_t sourceBLen = 1;
     Type sourceBElem = sourceBType;
-    if (auto sourceBVector = sourceBType.dyn_cast<VectorType>()) {
+    if (auto sourceBVector = llvm::dyn_cast<VectorType>(sourceBType)) {
       sourceBLen = sourceBVector.getNumElements();
       sourceBElem = sourceBVector.getElementType();
     }
     if (!sourceBElem.isFloat8E5M2FNUZ() && !sourceBElem.isFloat8E4M3FNUZ())
       return emitOpError("expected both source operands to have f8 elements");
     if (sourceLen != sourceBLen)
       return emitOpError(
           "expected both f8 source vectors to have the same length");

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

 
 #include "mlir/Dialect/Affine/IR/AffineOpsDialect.cpp.inc"
 
 /// A utility function to check if a value is defined at the top level of
 /// `region` or is an argument of `region`. A value of index type defined at the
 /// top level of a `AffineScope` region is always a valid symbol for all
 /// uses in that region.
 bool mlir::affine::isTopLevelValue(Value value, Region *region) {
-  if (auto arg = value.dyn_cast<BlockArgument>())
+  if (auto arg = llvm::dyn_cast<BlockArgument>(value))
     return arg.getParentRegion() == region;
   return value.getDefiningOp()->getParentRegion() == region;
 }
 
 /// Checks if `value` known to be a legal affine dimension or symbol in `src`
 /// region remains legal if the operation that uses it is inlined into `dest`
 /// with the given value mapping. `legalityCheck` is either `isValidDim` or
 /// `isValidSymbol`, depending on the value being required to remain a valid
 /// dimension or symbol.
 static bool
 remainsLegalAfterInline(Value value, Region *src, Region *dest,
                         const IRMapping &mapping,
                         function_ref<bool(Value, Region *)> legalityCheck) {
   // If the value is a valid dimension for any other reason than being
   // a top-level value, it will remain valid: constants get inlined
   // with the function, transitive affine applies also get inlined and
   // will be checked themselves, etc.
   if (!isTopLevelValue(value, src))
     return true;
 
   // If it's a top-level value because it's a block operand, i.e. a
   // function argument, check whether the value replacing it after
   // inlining is a valid dimension in the new region.
-  if (value.isa<BlockArgument>())
+  if (llvm::isa<BlockArgument>(value))
     return legalityCheck(mapping.lookup(value), dest);
 
   // If it's a top-level value because it's defined in the region,
   // it can only be inlined if the defining op is a constant or a
   // `dim`, which can appear anywhere and be valid, since the defining
   // op won't be top-level anymore after inlining.
   Attribute operandCst;
   bool isDimLikeOp = isa<ShapedDimOpInterface>(value.getDefiningOp());
Operation *AffineDialect::materializeConstant(OpBuilder &builder,
   return arith::ConstantOp::materialize(builder, value, type, loc);
 }
 
 /// A utility function to check if a value is defined at the top level of an
 /// op with trait `AffineScope`. If the value is defined in an unlinked region,
 /// conservatively assume it is not top-level. A value of index type defined at
 /// the top level is always a valid symbol.
 bool mlir::affine::isTopLevelValue(Value value) {
-  if (auto arg = value.dyn_cast<BlockArgument>()) {
+  if (auto arg = llvm::dyn_cast<BlockArgument>(value)) {
     // The block owning the argument may be unlinked, e.g. when the surrounding
     // region has not yet been attached to an Op, at which point the parent Op
     // is null.
     Operation *parentOp = arg.getOwner()->getParentOp();
     return parentOp && parentOp->hasTrait<OpTrait::AffineScope>();
   }
   // The defining Op may live in an unlinked block so its parent Op may be null.
   Operation *parentOp = value.getDefiningOp()->getParentOp();
bool mlir::affine::isValidDim(Value value) {
   if (!value.getType().isIndex())
     return false;
 
   if (auto *defOp = value.getDefiningOp())
     return isValidDim(value, getAffineScope(defOp));
 
   // This value has to be a block argument for an op that has the
   // `AffineScope` trait or for an affine.for or affine.parallel.
-  auto *parentOp = value.cast<BlockArgument>().getOwner()->getParentOp();
+  auto *parentOp = llvm::cast<BlockArgument>(value).getOwner()->getParentOp();
   return parentOp && (parentOp->hasTrait<OpTrait::AffineScope>() ||
                       isa<AffineForOp, AffineParallelOp>(parentOp));
 }
 
 // Value can be used as a dimension id iff it meets one of the following
 // conditions:
 // *) It is valid as a symbol.
 // *) It is an induction variable.
 // *) It is the result of an affine apply operation with dimension id operands.
 bool mlir::affine::isValidDim(Value value, Region *region) {
   // The value must be an index type.
   if (!value.getType().isIndex())
     return false;
 
   // All valid symbols are okay.
   if (isValidSymbol(value, region))
     return true;
 
   auto *op = value.getDefiningOp();
   if (!op) {
     // This value has to be a block argument for an affine.for or an
     // affine.parallel.
-    auto *parentOp = value.cast<BlockArgument>().getOwner()->getParentOp();
+    auto *parentOp = llvm::cast<BlockArgument>(value).getOwner()->getParentOp();
     return isa<AffineForOp, AffineParallelOp>(parentOp);
   }
 
   // Affine apply operation is ok if all of its operands are ok.
   if (auto applyOp = dyn_cast<AffineApplyOp>(op))
     return applyOp.isValidDim(region);
   // The dim op is okay if its operand memref/tensor is defined at the top
   // level.

 /// Returns true if the result of the dim op is a valid symbol for `region`.
 static bool isDimOpValidSymbol(ShapedDimOpInterface dimOp, Region *region) {
   // The dim op is okay if its source is defined at the top level.
   if (isTopLevelValue(dimOp.getShapedValue()))
     return true;
 
   // Conservatively handle remaining BlockArguments as non-valid symbols.
   // E.g. scf.for iterArgs.
-  if (dimOp.getShapedValue().template isa<BlockArgument>())
+  if (llvm::isa<BlockArgument>(dimOp.getShapedValue()))
     return false;
 
   // The dim op is also okay if its operand memref is a view/subview whose
   // corresponding size is a valid symbol.
   std::optional<int64_t> index = getConstantIntValue(dimOp.getDimension());
 
   // Be conservative if we can't understand the dimension.
   if (!index.has_value())
if (auto value = ofr.dyn_cast<Value>()) {
       actualValues.push_back(value);
       continue;
     }
     // Since we are directly specifying `index` as the result type, we need to
     // ensure the provided attribute is also an index type. Otherwise, the
     // AffineDialect materializer will create invalid `arith.constant`
     // operations if the provided Attribute is any other kind of integer.
     constants.push_back(dialect->materializeConstant(
-        b, b.getIndexAttr(ofr.get<Attribute>().cast<IntegerAttr>().getInt()),
+        b,
+        b.getIndexAttr(llvm::cast<IntegerAttr>(ofr.get<Attribute>()).getInt()),
         b.getIndexType(), loc));
     actualValues.push_back(constants.back()->getResult(0));
   }
 }
 
 /// Create an operation of the type provided as template argument and attempt to
 /// fold it immediately. The operation is expected to have a builder taking
 /// arbitrary `leadingArguments`, followed by a list of Value-typed `operands`.
if (srcMapOperands.size() != srcMapAttr.getValue().getNumInputs() ||
       dstMapOperands.size() != dstMapAttr.getValue().getNumInputs() ||
       tagMapOperands.size() != tagMapAttr.getValue().getNumInputs())
     return parser.emitError(parser.getNameLoc(),
                             "memref operand count not equal to map.numInputs");
   return success();
 }
 
 LogicalResult AffineDmaStartOp::verifyInvariantsImpl() {
-  if (!getOperand(getSrcMemRefOperandIndex()).getType().isa<MemRefType>())
+  if (!llvm::isa<MemRefType>(getOperand(getSrcMemRefOperandIndex()).getType()))
     return emitOpError("expected DMA source to be of memref type");
-  if (!getOperand(getDstMemRefOperandIndex()).getType().isa<MemRefType>())
+  if (!llvm::isa<MemRefType>(getOperand(getDstMemRefOperandIndex()).getType()))
     return emitOpError("expected DMA destination to be of memref type");
-  if (!getOperand(getTagMemRefOperandIndex()).getType().isa<MemRefType>())
+  if (!llvm::isa<MemRefType>(getOperand(getTagMemRefOperandIndex()).getType()))
     return emitOpError("expected DMA tag to be of memref type");
 
   unsigned numInputsAllMaps = getSrcMap().getNumInputs() +
                               getDstMap().getNumInputs() +
                               getTagMap().getNumInputs();
   if (getNumOperands() != numInputsAllMaps + 3 + 1 &&
       getNumOperands() != numInputsAllMaps + 3 + 1 + 2) {
     return emitOpError("incorrect number of operands");
if (parser.parseOperand(tagMemRefInfo) ||
                                     result.attributes) ||
       parser.parseComma() || parser.parseOperand(numElementsInfo) ||
       parser.parseColonType(type) ||
       parser.resolveOperand(tagMemRefInfo, type, result.operands) ||
       parser.resolveOperands(tagMapOperands, indexType, result.operands) ||
       parser.resolveOperand(numElementsInfo, indexType, result.operands))
     return failure();
 
-  if (!type.isa<MemRefType>())
+  if (!llvm::isa<MemRefType>(type))
     return parser.emitError(parser.getNameLoc(),
                             "expected tag to be of memref type");
 
   if (tagMapOperands.size() != tagMapAttr.getValue().getNumInputs())
     return parser.emitError(parser.getNameLoc(),
                             "tag memref operand count != to map.numInputs");
   return success();
 }
 
 LogicalResult AffineDmaWaitOp::verifyInvariantsImpl() {
-  if (!getOperand(0).getType().isa<MemRefType>())
+  if (!llvm::isa<MemRefType>(getOperand(0).getType()))
     return emitOpError("expected DMA tag to be of memref type");
   Region *scope = getAffineScope(*this);
   for (auto idx : getTagIndices()) {
     if (!idx.getType().isIndex())
       return emitOpError("index to dma_wait must have 'index' type");
     if (!isValidAffineIndexOperand(idx, scope))
       return emitOpError("index must be a dimension or symbol identifier");
   }
static ParseResult parseBound(bool isLower, OperationState &result,
   SMLoc attrLoc = p.getCurrentLocation();
 
   Attribute boundAttr;
   if (p.parseAttribute(boundAttr, builder.getIndexType(), boundAttrStrName,
                        result.attributes))
     return failure();
 
   // Parse full form - affine map followed by dim and symbol list.
-  if (auto affineMapAttr = boundAttr.dyn_cast<AffineMapAttr>()) {
+  if (auto affineMapAttr = llvm::dyn_cast<AffineMapAttr>(boundAttr)) {
     unsigned currentNumOperands = result.operands.size();
     unsigned numDims;
     if (parseDimAndSymbolList(p, result.operands, numDims))
       return failure();
 
     auto map = affineMapAttr.getValue();
     if (map.getNumDims() != numDims)
       return p.emitError(
if (map.getNumResults() > 1 && failedToParsedMinMax) {
       }
       return p.emitError(attrLoc, "upper loop bound affine map with multiple "
                                   "results requires 'min' prefix");
     }
     return success();
   }
 
   // Parse custom assembly form.
-  if (auto integerAttr = boundAttr.dyn_cast<IntegerAttr>()) {
+  if (auto integerAttr = llvm::dyn_cast<IntegerAttr>(boundAttr)) {
     result.attributes.pop_back();
     result.addAttribute(
         boundAttrStrName,
         AffineMapAttr::get(builder.getConstantAffineMap(integerAttr.getInt())));
     return success();
   }
 
   return p.emitError(
auto foldLowerOrUpperBound = [&forOp](bool lower) {
     assert(boundMap.getNumResults() >= 1 &&
            "bound maps should have at least one result");
     SmallVector<Attribute, 4> foldedResults;
     if (failed(boundMap.constantFold(operandConstants, foldedResults)))
       return failure();
 
     // Compute the max or min as applicable over the results.
     assert(!foldedResults.empty() && "bounds should have at least one result");
-    auto maxOrMin = foldedResults[0].cast<IntegerAttr>().getValue();
+    auto maxOrMin = llvm::cast<IntegerAttr>(foldedResults[0]).getValue();
     for (unsigned i = 1, e = foldedResults.size(); i < e; i++) {
-      auto foldedResult = foldedResults[i].cast<IntegerAttr>().getValue();
+      auto foldedResult = llvm::cast<IntegerAttr>(foldedResults[i]).getValue();
       maxOrMin = lower ? llvm::APIntOps::smax(maxOrMin, foldedResult)
                        : llvm::APIntOps::smin(maxOrMin, foldedResult);
     }
     lower ? forOp.setConstantLowerBound(maxOrMin.getSExtValue())
           : forOp.setConstantUpperBound(maxOrMin.getSExtValue());
     return success();
   };
 
bool mlir::affine::isAffineParallelInductionVar(Value val) {
   return getAffineParallelInductionVarOwner(val) != nullptr;
 }
 
 bool mlir::affine::isAffineInductionVar(Value val) {
   return isAffineForInductionVar(val) || isAffineParallelInductionVar(val);
 }
 
 AffineForOp mlir::affine::getForInductionVarOwner(Value val) {
-  auto ivArg = val.dyn_cast<BlockArgument>();
+  auto ivArg = llvm::dyn_cast<BlockArgument>(val);
   if (!ivArg || !ivArg.getOwner())
     return AffineForOp();
   auto *containingInst = ivArg.getOwner()->getParent()->getParentOp();
   if (auto forOp = dyn_cast<AffineForOp>(containingInst))
     // Check to make sure `val` is the induction variable, not an iter_arg.
     return forOp.getInductionVar() == val ? forOp : AffineForOp();
   return AffineForOp();
 }
 
 AffineParallelOp mlir::affine::getAffineParallelInductionVarOwner(Value val) {
-  auto ivArg = val.dyn_cast<BlockArgument>();
+  auto ivArg = llvm::dyn_cast<BlockArgument>(val);
   if (!ivArg || !ivArg.getOwner())
     return nullptr;
   Operation *containingOp = ivArg.getOwner()->getParentOp();
   auto parallelOp = dyn_cast<AffineParallelOp>(containingOp);
   if (parallelOp && llvm::is_contained(parallelOp.getIVs(), val))
     return parallelOp;
   return nullptr;
 }

 //===----------------------------------------------------------------------===//
 
 void AffineLoadOp::build(OpBuilder &builder, OperationState &result,
                          AffineMap map, ValueRange operands) {
   assert(operands.size() == 1 + map.getNumInputs() && "inconsistent operands");
   result.addOperands(operands);
   if (map)
     result.addAttribute(getMapAttrStrName(), AffineMapAttr::get(map));
-  auto memrefType = operands[0].getType().cast<MemRefType>();
+  auto memrefType = llvm::cast<MemRefType>(operands[0].getType());
   result.types.push_back(memrefType.getElementType());
 }
 
 void AffineLoadOp::build(OpBuilder &builder, OperationState &result,
                          Value memref, AffineMap map, ValueRange mapOperands) {
   assert(map.getNumInputs() == mapOperands.size() && "inconsistent index info");
   result.addOperands(memref);
   result.addOperands(mapOperands);
-  auto memrefType = memref.getType().cast<MemRefType>();
+  auto memrefType = llvm::cast<MemRefType>(memref.getType());
   result.addAttribute(getMapAttrStrName(), AffineMapAttr::get(map));
   result.types.push_back(memrefType.getElementType());
 }
 
 void AffineLoadOp::build(OpBuilder &builder, OperationState &result,
                          Value memref, ValueRange indices) {
-  auto memrefType = memref.getType().cast<MemRefType>();
+  auto memrefType = llvm::cast<MemRefType>(memref.getType());
   int64_t rank = memrefType.getRank();
   // Create identity map for memrefs with at least one dimension or () -> ()
   // for zero-dimensional memrefs.
   auto map =
       rank ? builder.getMultiDimIdentityMap(rank) : builder.getEmptyAffineMap();
   build(builder, result, memref, map, indices);
 }
 
if (!symbolTableOp)
     return {};
   auto global = dyn_cast_or_null<memref::GlobalOp>(
       SymbolTable::lookupSymbolIn(symbolTableOp, getGlobalOp.getNameAttr()));
   if (!global)
     return {};
 
   // Check if the global memref is a constant.
   auto cstAttr =
-      global.getConstantInitValue().dyn_cast_or_null<DenseElementsAttr>();
+      llvm::dyn_cast_or_null<DenseElementsAttr>(global.getConstantInitValue());
   if (!cstAttr)
     return {};
   // If it's a splat constant, we can fold irrespective of indices.
-  if (auto splatAttr = cstAttr.dyn_cast<SplatElementsAttr>())
+  if (auto splatAttr = llvm::dyn_cast<SplatElementsAttr>(cstAttr))
     return splatAttr.getSplatValue<Attribute>();
   // Otherwise, we can fold only if we know the indices.
   if (!getAffineMap().isConstant())
     return {};
   auto indices = llvm::to_vector<4>(
       llvm::map_range(getAffineMap().getConstantResults(),
                       [](int64_t v) -> uint64_t { return v; }));
   return cstAttr.getValues<Attribute>()[indices];
void AffineStoreOp::build(OpBuilder &builder, OperationState &result,
   result.addOperands(mapOperands);
   result.addAttribute(getMapAttrStrName(), AffineMapAttr::get(map));
 }
 
 // Use identity map.
 void AffineStoreOp::build(OpBuilder &builder, OperationState &result,
                           Value valueToStore, Value memref,
                           ValueRange indices) {
-  auto memrefType = memref.getType().cast<MemRefType>();
+  auto memrefType = llvm::cast<MemRefType>(memref.getType());
   int64_t rank = memrefType.getRank();
   // Create identity map for memrefs with at least one dimension or () -> ()
   // for zero-dimensional memrefs.
   auto map =
       rank ? builder.getMultiDimIdentityMap(rank) : builder.getEmptyAffineMap();
   build(builder, result, valueToStore, memref, map, indices);
 }
 
if (expectedNumUBResults != getUpperBoundsMap().getNumResults())
     return emitOpError() << "expected upper bounds map to have "
                          << expectedNumUBResults << " results";
 
   if (getReductions().size() != getNumResults())
     return emitOpError("a reduction must be specified for each output");
 
   // Verify reduction  ops are all valid
   for (Attribute attr : getReductions()) {
-    auto intAttr = attr.dyn_cast<IntegerAttr>();
+    auto intAttr = llvm::dyn_cast<IntegerAttr>(attr);
     if (!intAttr || !arith::symbolizeAtomicRMWKind(intAttr.getInt()))
       return emitOpError("invalid reduction attribute");
   }
 
   // Verify that the bound operands are valid dimension/symbols.
   /// Lower bounds.
   if (failed(verifyDimAndSymbolIdentifiers(*this, getLowerBoundsOperands(),
                                            getLowerBoundsMap().getNumDims())))
if (!elideSteps) {
     p << " step (";
     llvm::interleaveComma(steps, p);
     p << ')';
   }
   if (getNumResults()) {
     p << " reduce (";
     llvm::interleaveComma(getReductions(), p, [&](auto &attr) {
       arith::AtomicRMWKind sym = *arith::symbolizeAtomicRMWKind(
-          attr.template cast<IntegerAttr>().getInt());
+          llvm::cast<IntegerAttr>(attr).getInt());
       p << "\"" << arith::stringifyAtomicRMWKind(sym) << "\"";
     });
     p << ") -> (" << getResultTypes() << ")";
   }
 
   p << ' ';
   p.printRegion(getRegion(), /*printEntryBlockArgs=*/false,
                 /*printBlockTerminators=*/getNumResults());
void AffineVectorLoadOp::build(OpBuilder &builder, OperationState &result,
   result.addOperands(mapOperands);
   result.addAttribute(getMapAttrStrName(), AffineMapAttr::get(map));
   result.types.push_back(resultType);
 }
 
 void AffineVectorLoadOp::build(OpBuilder &builder, OperationState &result,
                                VectorType resultType, Value memref,
                                ValueRange indices) {
-  auto memrefType = memref.getType().cast<MemRefType>();
+  auto memrefType = llvm::cast<MemRefType>(memref.getType());
   int64_t rank = memrefType.getRank();
   // Create identity map for memrefs with at least one dimension or () -> ()
   // for zero-dimensional memrefs.
   auto map =
       rank ? builder.getMultiDimIdentityMap(rank) : builder.getEmptyAffineMap();
   build(builder, result, resultType, memref, map, indices);
 }
 
void AffineVectorStoreOp::build(OpBuilder &builder, OperationState &result,
   result.addOperands(mapOperands);
   result.addAttribute(getMapAttrStrName(), AffineMapAttr::get(map));
 }
 
 // Use identity map.
 void AffineVectorStoreOp::build(OpBuilder &builder, OperationState &result,
                                 Value valueToStore, Value memref,
                                 ValueRange indices) {
-  auto memrefType = memref.getType().cast<MemRefType>();
+  auto memrefType = llvm::cast<MemRefType>(memref.getType());
   int64_t rank = memrefType.getRank();
   // Create identity map for memrefs with at least one dimension or () -> ()
   // for zero-dimensional memrefs.
   auto map =
       rank ? builder.getMultiDimIdentityMap(rank) : builder.getEmptyAffineMap();
   build(builder, result, valueToStore, memref, map, indices);
 }
 void AffineVectorStoreOp::getCanonicalizationPatterns(

mlir/lib/Dialect/Arith/IR/ArithOps.cpp

 
 //===----------------------------------------------------------------------===//
 // Pattern helpers
 //===----------------------------------------------------------------------===//
 
 static IntegerAttr addIntegerAttrs(PatternRewriter &builder, Value res,
                                    Attribute lhs, Attribute rhs) {
   return builder.getIntegerAttr(res.getType(),
-                                lhs.cast<IntegerAttr>().getInt() +
-                                    rhs.cast<IntegerAttr>().getInt());
+                                llvm::cast<IntegerAttr>(lhs).getInt() +
+                                    llvm::cast<IntegerAttr>(rhs).getInt());
 }
 
 static IntegerAttr subIntegerAttrs(PatternRewriter &builder, Value res,
                                    Attribute lhs, Attribute rhs) {
   return builder.getIntegerAttr(res.getType(),
-                                lhs.cast<IntegerAttr>().getInt() -
-                                    rhs.cast<IntegerAttr>().getInt());
+                                llvm::cast<IntegerAttr>(lhs).getInt() -
+                                    llvm::cast<IntegerAttr>(rhs).getInt());
 }
 
 /// Invert an integer comparison predicate.
 arith::CmpIPredicate arith::invertPredicate(arith::CmpIPredicate pred) {
   switch (pred) {
   case arith::CmpIPredicate::eq:
     return arith::CmpIPredicate::ne;
   case arith::CmpIPredicate::ne:
static int64_t getScalarOrElementWidth(Type type) {
   return -1;
 }
 
 static int64_t getScalarOrElementWidth(Value value) {
   return getScalarOrElementWidth(value.getType());
 }
 
 static FailureOr<APInt> getIntOrSplatIntValue(Attribute attr) {
-  if (auto intAttr = attr.dyn_cast<IntegerAttr>())
+  if (auto intAttr = llvm::dyn_cast<IntegerAttr>(attr))
     return intAttr.getValue();
 
-  if (auto splatAttr = attr.dyn_cast<SplatElementsAttr>())
-    if (splatAttr.getElementType().isa<IntegerType>())
+  if (auto splatAttr = llvm::dyn_cast<SplatElementsAttr>(attr))
+    if (llvm::isa<IntegerType>(splatAttr.getElementType()))
       return splatAttr.getSplatValue<APInt>();
 
   return failure();
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd canonicalization patterns
 //===----------------------------------------------------------------------===//
 
 namespace {
 #include "ArithCanonicalization.inc"
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Common helpers
 //===----------------------------------------------------------------------===//
 
 /// Return the type of the same shape (scalar, vector or tensor) containing i1.
 static Type getI1SameShape(Type type) {
   auto i1Type = IntegerType::get(type.getContext(), 1);
-  if (auto tensorType = type.dyn_cast<RankedTensorType>())
+  if (auto tensorType = llvm::dyn_cast<RankedTensorType>(type))
     return RankedTensorType::get(tensorType.getShape(), i1Type);
-  if (type.isa<UnrankedTensorType>())
+  if (llvm::isa<UnrankedTensorType>(type))
     return UnrankedTensorType::get(i1Type);
-  if (auto vectorType = type.dyn_cast<VectorType>())
+  if (auto vectorType = llvm::dyn_cast<VectorType>(type))
     return VectorType::get(vectorType.getShape(), i1Type,
                            vectorType.getNumScalableDims());
   return i1Type;
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 void arith::ConstantOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   auto type = getType();
-  if (auto intCst = getValue().dyn_cast<IntegerAttr>()) {
-    auto intType = type.dyn_cast<IntegerType>();
+  if (auto intCst = llvm::dyn_cast<IntegerAttr>(getValue())) {
+    auto intType = llvm::dyn_cast<IntegerType>(type);
 
     // Sugar i1 constants with 'true' and 'false'.
     if (intType && intType.getWidth() == 1)
       return setNameFn(getResult(), (intCst.getInt() ? "true" : "false"));
 
     // Otherwise, build a complex name with the value and type.
     SmallString<32> specialNameBuffer;
     llvm::raw_svector_ostream specialName(specialNameBuffer);

 LogicalResult arith::ConstantOp::verify() {
   auto type = getType();
   // The value's type must match the return type.
   if (getValue().getType() != type) {
     return emitOpError() << "value type " << getValue().getType()
                          << " must match return type: " << type;
   }
   // Integer values must be signless.
-  if (type.isa<IntegerType>() && !type.cast<IntegerType>().isSignless())
+  if (llvm::isa<IntegerType>(type) &&
+      !llvm::cast<IntegerType>(type).isSignless())
     return emitOpError("integer return type must be signless");
   // Any float or elements attribute are acceptable.
-  if (!getValue().isa<IntegerAttr, FloatAttr, ElementsAttr>()) {
+  if (!llvm::isa<IntegerAttr, FloatAttr, ElementsAttr>(getValue())) {
     return emitOpError(
         "value must be an integer, float, or elements attribute");
   }
   return success();
 }
 
 bool arith::ConstantOp::isBuildableWith(Attribute value, Type type) {
   // The value's type must be the same as the provided type.
-  auto typedAttr = value.dyn_cast<TypedAttr>();
+  auto typedAttr = llvm::dyn_cast<TypedAttr>(value);
   if (!typedAttr || typedAttr.getType() != type)
     return false;
   // Integer values must be signless.
-  if (type.isa<IntegerType>() && !type.cast<IntegerType>().isSignless())
+  if (llvm::isa<IntegerType>(type) &&
+      !llvm::cast<IntegerType>(type).isSignless())
     return false;
   // Integer, float, and element attributes are buildable.
-  return value.isa<IntegerAttr, FloatAttr, ElementsAttr>();
+  return llvm::isa<IntegerAttr, FloatAttr, ElementsAttr>(value);
 }
 
 ConstantOp arith::ConstantOp::materialize(OpBuilder &builder, Attribute value,
                                           Type type, Location loc) {
   if (isBuildableWith(value, type))
     return builder.create<arith::ConstantOp>(loc, cast<TypedAttr>(value));
   return nullptr;
 }

 void arith::ConstantFloatOp::build(OpBuilder &builder, OperationState &result,
                                    const APFloat &value, FloatType type) {
   arith::ConstantOp::build(builder, result, type,
                            builder.getFloatAttr(type, value));
 }
 
 bool arith::ConstantFloatOp::classof(Operation *op) {
   if (auto constOp = dyn_cast_or_null<arith::ConstantOp>(op))
-    return constOp.getType().isa<FloatType>();
+    return llvm::isa<FloatType>(constOp.getType());
   return false;
 }
 
 void arith::ConstantIndexOp::build(OpBuilder &builder, OperationState &result,
                                    int64_t value) {
   arith::ConstantOp::build(builder, result, builder.getIndexType(),
                            builder.getIndexAttr(value));
 }

 }
 
 //===----------------------------------------------------------------------===//
 // AddUIExtendedOp
 //===----------------------------------------------------------------------===//
 
 std::optional<SmallVector<int64_t, 4>>
 arith::AddUIExtendedOp::getShapeForUnroll() {
-  if (auto vt = getType(0).dyn_cast<VectorType>())
+  if (auto vt = llvm::dyn_cast<VectorType>(getType(0)))
     return llvm::to_vector<4>(vt.getShape());
   return std::nullopt;
 }
 
 // Returns the overflow bit, assuming that `sum` is the result of unsigned
 // addition of `operand` and another number.
 static APInt calculateUnsignedOverflow(const APInt &sum, const APInt &operand) {
   return sum.ult(operand) ? APInt::getAllOnes(1) : APInt::getZero(1);
arith::AddUIExtendedOp::fold(FoldAdaptor adaptor,
   // Let the `constFoldBinaryOp` utility attempt to fold the sum of both
   // operands. If that succeeds, calculate the overflow bit based on the sum
   // and the first (constant) operand, `lhs`.
   if (Attribute sumAttr = constFoldBinaryOp<IntegerAttr>(
           adaptor.getOperands(),
           [](APInt a, const APInt &b) { return std::move(a) + b; })) {
     Attribute overflowAttr = constFoldBinaryOp<IntegerAttr>(
         ArrayRef({sumAttr, adaptor.getLhs()}),
-        getI1SameShape(sumAttr.cast<TypedAttr>().getType()),
+        getI1SameShape(llvm::cast<TypedAttr>(sumAttr).getType()),
         calculateUnsignedOverflow);
     if (!overflowAttr)
       return failure();
 
     results.push_back(sumAttr);
     results.push_back(overflowAttr);
     return success();
   }

 }
 
 //===----------------------------------------------------------------------===//
 // MulSIExtendedOp
 //===----------------------------------------------------------------------===//
 
 std::optional<SmallVector<int64_t, 4>>
 arith::MulSIExtendedOp::getShapeForUnroll() {
-  if (auto vt = getType(0).dyn_cast<VectorType>())
+  if (auto vt = llvm::dyn_cast<VectorType>(getType(0)))
     return llvm::to_vector<4>(vt.getShape());
   return std::nullopt;
 }
 
 LogicalResult
 arith::MulSIExtendedOp::fold(FoldAdaptor adaptor,
                              SmallVectorImpl<OpFoldResult> &results) {
   // mulsi_extended(x, 0) -> 0, 0

 }
 
 //===----------------------------------------------------------------------===//
 // MulUIExtendedOp
 //===----------------------------------------------------------------------===//
 
 std::optional<SmallVector<int64_t, 4>>
 arith::MulUIExtendedOp::getShapeForUnroll() {
-  if (auto vt = getType(0).dyn_cast<VectorType>())
+  if (auto vt = llvm::dyn_cast<VectorType>(getType(0)))
     return llvm::to_vector<4>(vt.getShape());
   return std::nullopt;
 }
 
 LogicalResult
 arith::MulUIExtendedOp::fold(FoldAdaptor adaptor,
                              SmallVectorImpl<OpFoldResult> &results) {
   // mului_extended(x, 0) -> 0, 0

 using type_list = std::tuple<Types...> *;
 
 /// Returns a non-null type only if the provided type is one of the allowed
 /// types or one of the allowed shaped types of the allowed types. Returns the
 /// element type if a valid shaped type is provided.
 template <typename... ShapedTypes, typename... ElementTypes>
 static Type getUnderlyingType(Type type, type_list<ShapedTypes...>,
                               type_list<ElementTypes...>) {
-  if (type.isa<ShapedType>() && !type.isa<ShapedTypes...>())
+  if (llvm::isa<ShapedType>(type) && !llvm::isa<ShapedTypes...>(type))
     return {};
 
   auto underlyingType = getElementTypeOrSelf(type);
-  if (!underlyingType.isa<ElementTypes...>())
+  if (!llvm::isa<ElementTypes...>(underlyingType))
     return {};
 
   return underlyingType;
 }
 
 /// Get allowed underlying types for vectors and tensors.
 template <typename... ElementTypes>
 static Type getTypeIfLike(Type type) {

 //===----------------------------------------------------------------------===//
 
 // Extend ops can only extend to a wider type.
 template <typename ValType, typename Op>
 static LogicalResult verifyExtOp(Op op) {
   Type srcType = getElementTypeOrSelf(op.getIn().getType());
   Type dstType = getElementTypeOrSelf(op.getType());
 
-  if (srcType.cast<ValType>().getWidth() >= dstType.cast<ValType>().getWidth())
+  if (llvm::cast<ValType>(srcType).getWidth() >=
+      llvm::cast<ValType>(dstType).getWidth())
     return op.emitError("result type ")
            << dstType << " must be wider than operand type " << srcType;
 
   return success();
 }
 
 // Truncate ops can only truncate to a shorter type.
 template <typename ValType, typename Op>
 static LogicalResult verifyTruncateOp(Op op) {
   Type srcType = getElementTypeOrSelf(op.getIn().getType());
   Type dstType = getElementTypeOrSelf(op.getType());
 
-  if (srcType.cast<ValType>().getWidth() <= dstType.cast<ValType>().getWidth())
+  if (llvm::cast<ValType>(srcType).getWidth() <=
+      llvm::cast<ValType>(dstType).getWidth())
     return op.emitError("result type ")
            << dstType << " must be shorter than operand type " << srcType;
 
   return success();
 }
 
 /// Validate a cast that changes the width of a type.
 template <template <typename> class WidthComparator, typename... ElementTypes>

 
 OpFoldResult arith::ExtUIOp::fold(FoldAdaptor adaptor) {
   if (auto lhs = getIn().getDefiningOp<ExtUIOp>()) {
     getInMutable().assign(lhs.getIn());
     return getResult();
   }
 
   Type resType = getElementTypeOrSelf(getType());
-  unsigned bitWidth = resType.cast<IntegerType>().getWidth();
+  unsigned bitWidth = llvm::cast<IntegerType>(resType).getWidth();
   return constFoldCastOp<IntegerAttr, IntegerAttr>(
       adaptor.getOperands(), getType(),
       [bitWidth](const APInt &a, bool &castStatus) {
         return a.zext(bitWidth);
       });
 }
 
 bool arith::ExtUIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {

 
 OpFoldResult arith::ExtSIOp::fold(FoldAdaptor adaptor) {
   if (auto lhs = getIn().getDefiningOp<ExtSIOp>()) {
     getInMutable().assign(lhs.getIn());
     return getResult();
   }
 
   Type resType = getElementTypeOrSelf(getType());
-  unsigned bitWidth = resType.cast<IntegerType>().getWidth();
+  unsigned bitWidth = llvm::cast<IntegerType>(resType).getWidth();
   return constFoldCastOp<IntegerAttr, IntegerAttr>(
       adaptor.getOperands(), getType(),
       [bitWidth](const APInt &a, bool &castStatus) {
         return a.sext(bitWidth);
       });
 }
 
 bool arith::ExtSIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {

 OpFoldResult arith::TruncIOp::fold(FoldAdaptor adaptor) {
   if (matchPattern(getOperand(), m_Op<arith::ExtUIOp>()) ||
       matchPattern(getOperand(), m_Op<arith::ExtSIOp>())) {
     Value src = getOperand().getDefiningOp()->getOperand(0);
     Type srcType = getElementTypeOrSelf(src.getType());
     Type dstType = getElementTypeOrSelf(getType());
     // trunci(zexti(a)) -> trunci(a)
     // trunci(sexti(a)) -> trunci(a)
-    if (srcType.cast<IntegerType>().getWidth() >
-        dstType.cast<IntegerType>().getWidth()) {
+    if (llvm::cast<IntegerType>(srcType).getWidth() >
+        llvm::cast<IntegerType>(dstType).getWidth()) {
       setOperand(src);
       return getResult();
     }
     // trunci(zexti(a)) -> a
     // trunci(sexti(a)) -> a
     return src;
   }
 
   // trunci(trunci(a)) -> trunci(a))
   if (matchPattern(getOperand(), m_Op<arith::TruncIOp>())) {
     setOperand(getOperand().getDefiningOp()->getOperand(0));
     return getResult();
   }
 
   Type resType = getElementTypeOrSelf(getType());
-  unsigned bitWidth = resType.cast<IntegerType>().getWidth();
+  unsigned bitWidth = llvm::cast<IntegerType>(resType).getWidth();
   return constFoldCastOp<IntegerAttr, IntegerAttr>(
       adaptor.getOperands(), getType(),
       [bitWidth](const APInt &a, bool &castStatus) {
         return a.trunc(bitWidth);
       });
 }
 
 bool arith::TruncIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {

 //===----------------------------------------------------------------------===//
 // TruncFOp
 //===----------------------------------------------------------------------===//
 
 /// Perform safe const propagation for truncf, i.e. only propagate if FP value
 /// can be represented without precision loss or rounding.
 OpFoldResult arith::TruncFOp::fold(FoldAdaptor adaptor) {
   auto constOperand = adaptor.getIn();
-  if (!constOperand || !constOperand.isa<FloatAttr>())
+  if (!constOperand || !llvm::isa<FloatAttr>(constOperand))
     return {};
 
   // Convert to target type via 'double'.
   double sourceValue =
-      constOperand.dyn_cast<FloatAttr>().getValue().convertToDouble();
+      llvm::dyn_cast<FloatAttr>(constOperand).getValue().convertToDouble();
   auto targetAttr = FloatAttr::get(getType(), sourceValue);
 
   // Propagate if constant's value does not change after truncation.
   if (sourceValue == targetAttr.getValue().convertToDouble())
     return targetAttr;
 
   return {};
 }
bool arith::UIToFPOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkIntFloatCast<IntegerType, FloatType>(inputs, outputs);
 }
 
 OpFoldResult arith::UIToFPOp::fold(FoldAdaptor adaptor) {
   Type resEleType = getElementTypeOrSelf(getType());
   return constFoldCastOp<IntegerAttr, FloatAttr>(
       adaptor.getOperands(), getType(),
       [&resEleType](const APInt &a, bool &castStatus) {
-        FloatType floatTy = resEleType.cast<FloatType>();
+        FloatType floatTy = llvm::cast<FloatType>(resEleType);
         APFloat apf(floatTy.getFloatSemantics(),
                     APInt::getZero(floatTy.getWidth()));
         apf.convertFromAPInt(a, /*IsSigned=*/false,
                              APFloat::rmNearestTiesToEven);
         return apf;
       });
 }
 
 //===----------------------------------------------------------------------===//
 // SIToFPOp
 //===----------------------------------------------------------------------===//
 
 bool arith::SIToFPOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkIntFloatCast<IntegerType, FloatType>(inputs, outputs);
 }
 
 OpFoldResult arith::SIToFPOp::fold(FoldAdaptor adaptor) {
   Type resEleType = getElementTypeOrSelf(getType());
   return constFoldCastOp<IntegerAttr, FloatAttr>(
       adaptor.getOperands(), getType(),
       [&resEleType](const APInt &a, bool &castStatus) {
-        FloatType floatTy = resEleType.cast<FloatType>();
+        FloatType floatTy = llvm::cast<FloatType>(resEleType);
         APFloat apf(floatTy.getFloatSemantics(),
                     APInt::getZero(floatTy.getWidth()));
         apf.convertFromAPInt(a, /*IsSigned=*/true,
                              APFloat::rmNearestTiesToEven);
         return apf;
       });
 }
 //===----------------------------------------------------------------------===//
 // FPToUIOp
 //===----------------------------------------------------------------------===//
 
 bool arith::FPToUIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkIntFloatCast<FloatType, IntegerType>(inputs, outputs);
 }
 
 OpFoldResult arith::FPToUIOp::fold(FoldAdaptor adaptor) {
   Type resType = getElementTypeOrSelf(getType());
-  unsigned bitWidth = resType.cast<IntegerType>().getWidth();
+  unsigned bitWidth = llvm::cast<IntegerType>(resType).getWidth();
   return constFoldCastOp<FloatAttr, IntegerAttr>(
       adaptor.getOperands(), getType(),
       [&bitWidth](const APFloat &a, bool &castStatus) {
         bool ignored;
         APSInt api(bitWidth, /*isUnsigned=*/true);
         castStatus = APFloat::opInvalidOp !=
                      a.convertToInteger(api, APFloat::rmTowardZero, &ignored);
         return api;
       });
 }
 
 //===----------------------------------------------------------------------===//
 // FPToSIOp
 //===----------------------------------------------------------------------===//
 
 bool arith::FPToSIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return checkIntFloatCast<FloatType, IntegerType>(inputs, outputs);
 }
 
 OpFoldResult arith::FPToSIOp::fold(FoldAdaptor adaptor) {
   Type resType = getElementTypeOrSelf(getType());
-  unsigned bitWidth = resType.cast<IntegerType>().getWidth();
+  unsigned bitWidth = llvm::cast<IntegerType>(resType).getWidth();
   return constFoldCastOp<FloatAttr, IntegerAttr>(
       adaptor.getOperands(), getType(),
       [&bitWidth](const APFloat &a, bool &castStatus) {
         bool ignored;
         APSInt api(bitWidth, /*isUnsigned=*/false);
         castStatus = APFloat::opInvalidOp !=
                      a.convertToInteger(api, APFloat::rmTowardZero, &ignored);
         return api;

 
 OpFoldResult arith::BitcastOp::fold(FoldAdaptor adaptor) {
   auto resType = getType();
   auto operand = adaptor.getIn();
   if (!operand)
     return {};
 
   /// Bitcast dense elements.
-  if (auto denseAttr = operand.dyn_cast_or_null<DenseElementsAttr>())
-    return denseAttr.bitcast(resType.cast<ShapedType>().getElementType());
+  if (auto denseAttr = llvm::dyn_cast_or_null<DenseElementsAttr>(operand))
+    return denseAttr.bitcast(llvm::cast<ShapedType>(resType).getElementType());
   /// Other shaped types unhandled.
-  if (resType.isa<ShapedType>())
+  if (llvm::isa<ShapedType>(resType))
     return {};
 
   /// Bitcast integer or float to integer or float.
-  APInt bits = operand.isa<FloatAttr>()
-                   ? operand.cast<FloatAttr>().getValue().bitcastToAPInt()
-                   : operand.cast<IntegerAttr>().getValue();
+  APInt bits = llvm::isa<FloatAttr>(operand)
+                   ? llvm::cast<FloatAttr>(operand).getValue().bitcastToAPInt()
+                   : llvm::cast<IntegerAttr>(operand).getValue();
 
-  if (auto resFloatType = resType.dyn_cast<FloatType>())
+  if (auto resFloatType = llvm::dyn_cast<FloatType>(resType))
     return FloatAttr::get(resType,
                           APFloat(resFloatType.getFloatSemantics(), bits));
   return IntegerAttr::get(resType, bits);
 }
 
 void arith::BitcastOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                    MLIRContext *context) {
   patterns.add<BitcastOfBitcast>(context);
static bool applyCmpPredicateToEqualOperands(arith::CmpIPredicate predicate) {
   case arith::CmpIPredicate::ugt:
     return false;
   }
   llvm_unreachable("unknown cmpi predicate kind");
 }
 
 static Attribute getBoolAttribute(Type type, MLIRContext *ctx, bool value) {
   auto boolAttr = BoolAttr::get(ctx, value);
-  ShapedType shapedType = type.dyn_cast_or_null<ShapedType>();
+  ShapedType shapedType = llvm::dyn_cast_or_null<ShapedType>(type);
   if (!shapedType)
     return boolAttr;
   return DenseElementsAttr::get(shapedType, boolAttr);
 }
 
 static std::optional<int64_t> getIntegerWidth(Type t) {
-  if (auto intType = t.dyn_cast<IntegerType>()) {
+  if (auto intType = llvm::dyn_cast<IntegerType>(t)) {
     return intType.getWidth();
   }
-  if (auto vectorIntType = t.dyn_cast<VectorType>()) {
-    return vectorIntType.getElementType().cast<IntegerType>().getWidth();
+  if (auto vectorIntType = llvm::dyn_cast<VectorType>(t)) {
+    return llvm::cast<IntegerType>(vectorIntType.getElementType()).getWidth();
   }
   return std::nullopt;
 }
 
 OpFoldResult arith::CmpIOp::fold(FoldAdaptor adaptor) {
   // cmpi(pred, x, x)
   if (getLhs() == getRhs()) {
     auto val = applyCmpPredicateToEqualOperands(getPredicate());
LogicalResult matchAndRewrite(CmpFOp op,
     const APFloat &rhs = flt.getValue();
 
     // Don't attempt to fold a nan.
     if (rhs.isNaN())
       return failure();
 
     // Get the width of the mantissa.  We don't want to hack on conversions that
     // might lose information from the integer, e.g. "i64 -> float"
-    FloatType floatTy = op.getRhs().getType().cast<FloatType>();
+    FloatType floatTy = llvm::cast<FloatType>(op.getRhs().getType());
     int mantissaWidth = floatTy.getFPMantissaWidth();
     if (mantissaWidth <= 0)
       return failure();
 
     bool isUnsigned;
     Value intVal;
 
     if (auto si = op.getLhs().getDefiningOp<SIToFPOp>()) {
       isUnsigned = false;
       intVal = si.getIn();
     } else if (auto ui = op.getLhs().getDefiningOp<UIToFPOp>()) {
       isUnsigned = true;
       intVal = ui.getIn();
     } else {
       return failure();
     }
 
     // Check to see that the input is converted from an integer type that is
     // small enough that preserves all bits.
-    auto intTy = intVal.getType().cast<IntegerType>();
+    auto intTy = llvm::cast<IntegerType>(intVal.getType());
     auto intWidth = intTy.getWidth();
 
     // Number of bits representing values, as opposed to the sign
     auto valueBits = isUnsigned ? intWidth : (intWidth - 1);
 
     // Following test does NOT adjust intWidth downwards for signed inputs,
     // because the most negative value still requires all the mantissa bits
     // to distinguish it from one less than that value.

 
 //  select %arg, %c1, %c0 => extui %arg
 struct SelectToExtUI : public OpRewritePattern<arith::SelectOp> {
   using OpRewritePattern<arith::SelectOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(arith::SelectOp op,
                                 PatternRewriter &rewriter) const override {
     // Cannot extui i1 to i1, or i1 to f32
-    if (!op.getType().isa<IntegerType>() || op.getType().isInteger(1))
+    if (!llvm::isa<IntegerType>(op.getType()) || op.getType().isInteger(1))
       return failure();
 
     // select %x, c1, %c0 => extui %arg
     if (matchPattern(op.getTrueValue(), m_One()) &&
         matchPattern(op.getFalseValue(), m_Zero())) {
       rewriter.replaceOpWithNewOp<arith::ExtUIOp>(op, op.getType(),
                                                   op.getCondition());
       return success();
return parser.resolveOperands(operands,
                                 {conditionType, resultType, resultType},
                                 parser.getNameLoc(), result.operands);
 }
 
 void arith::SelectOp::print(OpAsmPrinter &p) {
   p << " " << getOperands();
   p.printOptionalAttrDict((*this)->getAttrs());
   p << " : ";
-  if (ShapedType condType = getCondition().getType().dyn_cast<ShapedType>())
+  if (ShapedType condType =
+          llvm::dyn_cast<ShapedType>(getCondition().getType()))
     p << condType << ", ";
   p << getType();
 }
 
 LogicalResult arith::SelectOp::verify() {
   Type conditionType = getCondition().getType();
   if (conditionType.isSignlessInteger(1))
     return success();
 
   // If the result type is a vector or tensor, the type can be a mask with the
   // same elements.
   Type resultType = getType();
-  if (!resultType.isa<TensorType, VectorType>())
+  if (!llvm::isa<TensorType, VectorType>(resultType))
     return emitOpError() << "expected condition to be a signless i1, but got "
                          << conditionType;
   Type shapedConditionType = getI1SameShape(resultType);
   if (conditionType != shapedConditionType) {
     return emitOpError() << "expected condition type to have the same shape "
                             "as the result type, expected "
                          << shapedConditionType << ", but got "
                          << conditionType;

 
 /// Returns the identity value attribute associated with an AtomicRMWKind op.
 TypedAttr mlir::arith::getIdentityValueAttr(AtomicRMWKind kind, Type resultType,
                                             OpBuilder &builder, Location loc) {
   switch (kind) {
   case AtomicRMWKind::maxf:
     return builder.getFloatAttr(
         resultType,
-        APFloat::getInf(resultType.cast<FloatType>().getFloatSemantics(),
+        APFloat::getInf(llvm::cast<FloatType>(resultType).getFloatSemantics(),
                         /*Negative=*/true));
   case AtomicRMWKind::addf:
   case AtomicRMWKind::addi:
   case AtomicRMWKind::maxu:
   case AtomicRMWKind::ori:
     return builder.getZeroAttr(resultType);
   case AtomicRMWKind::andi:
     return builder.getIntegerAttr(
         resultType,
-        APInt::getAllOnes(resultType.cast<IntegerType>().getWidth()));
+        APInt::getAllOnes(llvm::cast<IntegerType>(resultType).getWidth()));
   case AtomicRMWKind::maxs:
     return builder.getIntegerAttr(
-        resultType,
-        APInt::getSignedMinValue(resultType.cast<IntegerType>().getWidth()));
+        resultType, APInt::getSignedMinValue(
+                        llvm::cast<IntegerType>(resultType).getWidth()));
   case AtomicRMWKind::minf:
     return builder.getFloatAttr(
         resultType,
-        APFloat::getInf(resultType.cast<FloatType>().getFloatSemantics(),
+        APFloat::getInf(llvm::cast<FloatType>(resultType).getFloatSemantics(),
                         /*Negative=*/false));
   case AtomicRMWKind::mins:
     return builder.getIntegerAttr(
-        resultType,
-        APInt::getSignedMaxValue(resultType.cast<IntegerType>().getWidth()));
+        resultType, APInt::getSignedMaxValue(
+                        llvm::cast<IntegerType>(resultType).getWidth()));
   case AtomicRMWKind::minu:
     return builder.getIntegerAttr(
         resultType,
-        APInt::getMaxValue(resultType.cast<IntegerType>().getWidth()));
+        APInt::getMaxValue(llvm::cast<IntegerType>(resultType).getWidth()));
   case AtomicRMWKind::muli:
     return builder.getIntegerAttr(resultType, 1);
   case AtomicRMWKind::mulf:
     return builder.getFloatAttr(resultType, 1);
   // TODO: Add remaining reduction operations.
   default:
     (void)emitOptionalError(loc, "Reduction operation type not supported");
     break;

mlir/lib/Dialect/Arith/IR/InferIntRangeInterfaceImpls.cpp

 using namespace mlir::intrange;
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 void arith::ConstantOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
                                           SetIntRangeFn setResultRange) {
-  auto constAttr = getValue().dyn_cast_or_null<IntegerAttr>();
+  auto constAttr = llvm::dyn_cast_or_null<IntegerAttr>(getValue());
   if (constAttr) {
     const APInt &value = constAttr.getValue();
     setResultRange(getResult(), ConstantIntRanges::constant(value));
   }
 }
 
 //===----------------------------------------------------------------------===//
 // AddIOp

mlir/lib/Dialect/Arith/IR/ValueBoundsOpInterfaceImpl.cpp

 struct ConstantOpInterface
     : public ValueBoundsOpInterface::ExternalModel<ConstantOpInterface,
                                                    ConstantOp> {
   void populateBoundsForIndexValue(Operation *op, Value value,
                                    ValueBoundsConstraintSet &cstr) const {
     auto constantOp = cast<ConstantOp>(op);
     assert(value == constantOp.getResult() && "invalid value");
 
-    if (auto attr = constantOp.getValue().dyn_cast<IntegerAttr>())
+    if (auto attr = llvm::dyn_cast<IntegerAttr>(constantOp.getValue()))
       cstr.bound(value) == attr.getInt();
   }
 };
 
 struct SubIOpInterface
     : public ValueBoundsOpInterface::ExternalModel<SubIOpInterface, SubIOp> {
   void populateBoundsForIndexValue(Operation *op, Value value,
                                    ValueBoundsConstraintSet &cstr) const {

mlir/lib/Dialect/ArmSVE/IR/ArmSVEDialect.cpp

 
 //===----------------------------------------------------------------------===//
 // ScalableVector versions of general helpers for comparison ops
 //===----------------------------------------------------------------------===//
 
 /// Return the scalable vector of the same shape and containing i1.
 static Type getI1SameShape(Type type) {
   auto i1Type = IntegerType::get(type.getContext(), 1);
-  if (auto sVectorType = type.dyn_cast<VectorType>())
+  if (auto sVectorType = llvm::dyn_cast<VectorType>(type))
     return VectorType::get(sVectorType.getShape(), i1Type,
                            sVectorType.getNumScalableDims());
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // Tablegen Definitions
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/Async/IR/Async.cpp

 //===----------------------------------------------------------------------===//
 
 LogicalResult YieldOp::verify() {
   // Get the underlying value types from async values returned from the
   // parent `async.execute` operation.
   auto executeOp = (*this)->getParentOfType<ExecuteOp>();
   auto types =
       llvm::map_range(executeOp.getBodyResults(), [](const OpResult &result) {
-        return result.getType().cast<ValueType>().getValueType();
+        return llvm::cast<ValueType>(result.getType()).getValueType();
       });
 
   if (getOperandTypes() != types)
     return emitOpError("operand types do not match the types returned from "
                        "the parent ExecuteOp");
 
   return success();
 }

 OperandRange
 ExecuteOp::getSuccessorEntryOperands(std::optional<unsigned> index) {
   assert(index && *index == 0 && "invalid region index");
   return getBodyOperands();
 }
 
 bool ExecuteOp::areTypesCompatible(Type lhs, Type rhs) {
   const auto getValueOrTokenType = [](Type type) {
-    if (auto value = type.dyn_cast<ValueType>())
+    if (auto value = llvm::dyn_cast<ValueType>(type))
       return value.getValueType();
     return type;
   };
   return getValueOrTokenType(lhs) == getValueOrTokenType(rhs);
 }
 
 void ExecuteOp::getSuccessorRegions(std::optional<unsigned> index,
                                     ArrayRef<Attribute>,
void ExecuteOp::build(OpBuilder &builder, OperationState &result,
   for (Type type : resultTypes)
     result.addTypes(ValueType::get(type));
 
   // Add a body region with block arguments as unwrapped async value operands.
   Region *bodyRegion = result.addRegion();
   bodyRegion->push_back(new Block);
   Block &bodyBlock = bodyRegion->front();
   for (Value operand : operands) {
-    auto valueType = operand.getType().dyn_cast<ValueType>();
+    auto valueType = llvm::dyn_cast<ValueType>(operand.getType());
     bodyBlock.addArgument(valueType ? valueType.getValueType()
                                     : operand.getType(),
                           operand.getLoc());
   }
 
   // Create the default terminator if the builder is not provided and if the
   // expected result is empty. Otherwise, leave this to the caller
   // because we don't know which values to return from the execute op.
ParseResult ExecuteOp::parse(OpAsmParser &parser, OperationState &result) {
   // Parse a single instance of `%value as %unwrapped : !async.value<!type>`.
   auto parseAsyncValueArg = [&]() -> ParseResult {
     if (parser.parseOperand(valueArgs.emplace_back()) ||
         parser.parseKeyword("as") ||
         parser.parseArgument(unwrappedArgs.emplace_back()) ||
         parser.parseColonType(valueTypes.emplace_back()))
       return failure();
 
-    auto valueTy = valueTypes.back().dyn_cast<ValueType>();
+    auto valueTy = llvm::dyn_cast<ValueType>(valueTypes.back());
     unwrappedArgs.back().type = valueTy ? valueTy.getValueType() : Type();
     return success();
   };
 
   auto argsLoc = parser.getCurrentLocation();
   if (parser.parseCommaSeparatedList(OpAsmParser::Delimiter::OptionalParen,
                                      parseAsyncValueArg) ||
       parser.resolveOperands(valueArgs, valueTypes, argsLoc, result.operands))
ParseResult ExecuteOp::parse(OpAsmParser &parser, OperationState &result) {
   // Parse asynchronous region.
   Region *body = result.addRegion();
   return parser.parseRegion(*body, /*arguments=*/unwrappedArgs);
 }
 
 LogicalResult ExecuteOp::verifyRegions() {
   // Unwrap async.execute value operands types.
   auto unwrappedTypes = llvm::map_range(getBodyOperands(), [](Value operand) {
-    return operand.getType().cast<ValueType>().getValueType();
+    return llvm::cast<ValueType>(operand.getType()).getValueType();
   });
 
   // Verify that unwrapped argument types matches the body region arguments.
   if (getBodyRegion().getArgumentTypes() != unwrappedTypes)
     return emitOpError("async body region argument types do not match the "
                        "execute operation arguments types");
 
   return success();

 //===----------------------------------------------------------------------===//
 
 void AwaitOp::build(OpBuilder &builder, OperationState &result, Value operand,
                     ArrayRef<NamedAttribute> attrs) {
   result.addOperands({operand});
   result.attributes.append(attrs.begin(), attrs.end());
 
   // Add unwrapped async.value type to the returned values types.
-  if (auto valueType = operand.getType().dyn_cast<ValueType>())
+  if (auto valueType = llvm::dyn_cast<ValueType>(operand.getType()))
     result.addTypes(valueType.getValueType());
 }
 
 static ParseResult parseAwaitResultType(OpAsmParser &parser, Type &operandType,
                                         Type &resultType) {
   if (parser.parseType(operandType))
     return failure();
 
   // Add unwrapped async.value type to the returned values types.
-  if (auto valueType = operandType.dyn_cast<ValueType>())
+  if (auto valueType = llvm::dyn_cast<ValueType>(operandType))
     resultType = valueType.getValueType();
 
   return success();
 }
 
 static void printAwaitResultType(OpAsmPrinter &p, Operation *op,
                                  Type operandType, Type resultType) {
   p << operandType;
 }
 
 LogicalResult AwaitOp::verify() {
   Type argType = getOperand().getType();
 
   // Awaiting on a token does not have any results.
-  if (argType.isa<TokenType>() && !getResultTypes().empty())
+  if (llvm::isa<TokenType>(argType) && !getResultTypes().empty())
     return emitOpError("awaiting on a token must have empty result");
 
   // Awaiting on a value unwraps the async value type.
-  if (auto value = argType.dyn_cast<ValueType>()) {
+  if (auto value = llvm::dyn_cast<ValueType>(argType)) {
     if (*getResultType() != value.getValueType())
       return emitOpError() << "result type " << *getResultType()
                            << " does not match async value type "
                            << value.getValueType();
   }
 
   return success();
 }
LogicalResult FuncOp::verify() {
   auto resultTypes = getResultTypes();
   if (resultTypes.empty())
     return emitOpError()
            << "result is expected to be at least of size 1, but got "
            << resultTypes.size();
 
   for (unsigned i = 0, e = resultTypes.size(); i != e; ++i) {
     auto type = resultTypes[i];
-    if (!type.isa<TokenType>() && !type.isa<ValueType>())
+    if (!llvm::isa<TokenType>(type) && !llvm::isa<ValueType>(type))
       return emitOpError() << "result type must be async value type or async "
                               "token type, but got "
                            << type;
     // We only allow AsyncToken appear as the first return value
-    if (type.isa<TokenType>() && i != 0) {
+    if (llvm::isa<TokenType>(type) && i != 0) {
       return emitOpError()
              << " results' (optional) async token type is expected "
                 "to appear as the 1st return value, but got "
              << i + 1;
     }
   }
 
   return success();

 LogicalResult ReturnOp::verify() {
   auto funcOp = (*this)->getParentOfType<FuncOp>();
   ArrayRef<Type> resultTypes = funcOp.isStateful()
                                    ? funcOp.getResultTypes().drop_front()
                                    : funcOp.getResultTypes();
   // Get the underlying value types from async types returned from the
   // parent `async.func` operation.
   auto types = llvm::map_range(resultTypes, [](const Type &result) {
-    return result.cast<ValueType>().getValueType();
+    return llvm::cast<ValueType>(result).getValueType();
   });
 
   if (getOperandTypes() != types)
     return emitOpError("operand types do not match the types returned from "
                        "the parent FuncOp");
 
   return success();
 }

mlir/lib/Dialect/Bufferization/IR/BufferizableOpInterface.cpp

Region *bufferization::getNextEnclosingRepetitiveRegion(
   while ((region = region->getParentRegion())) {
     if (isRepetitiveRegion(region, options))
       break;
   }
   return region;
 }
 
 Operation *bufferization::getOwnerOfValue(Value value) {
-  if (auto opResult = value.dyn_cast<OpResult>())
+  if (auto opResult = llvm::dyn_cast<OpResult>(value))
     return opResult.getDefiningOp();
-  return value.cast<BlockArgument>().getOwner()->getParentOp();
+  return llvm::cast<BlockArgument>(value).getOwner()->getParentOp();
 }
 
 bool bufferization::allocationDoesNotEscape(OpResult opResult) {
 #ifndef NDEBUG
   auto bufferizableOp = opResult.getDefiningOp<BufferizableOpInterface>();
   assert(bufferizableOp && bufferizableOp.bufferizesToAllocation(opResult) &&
          "expected op that bufferizes to an allocation");
 #endif // NDEBUG
 
   Operation *op = opResult.getDefiningOp();
   // If there is no 'escape' attribute, we cannot say for sure.
   if (!op->hasAttr(BufferizationDialect::kEscapeAttrName))
     return false;
   auto attr =
       op->getAttrOfType<ArrayAttr>(BufferizationDialect::kEscapeAttrName);
-  return !attr[opResult.getResultNumber()].cast<BoolAttr>().getValue();
+  return !llvm::cast<BoolAttr>(attr[opResult.getResultNumber()]).getValue();
 }
 
 /// Create an AllocTensorOp for the given shaped value. If `copy` is set, the
 /// shaped value is copied. Otherwise, a tensor with undefined contents is
 /// allocated.
 FailureOr<Value> bufferization::allocateTensorForShapedValue(
     OpBuilder &b, Location loc, Value shapedValue, bool escape,
     const BufferizationOptions &options, bool copy) {
   Value tensor;
-  if (shapedValue.getType().isa<RankedTensorType>()) {
+  if (llvm::isa<RankedTensorType>(shapedValue.getType())) {
     tensor = shapedValue;
-  } else if (shapedValue.getType().isa<MemRefType>()) {
+  } else if (llvm::isa<MemRefType>(shapedValue.getType())) {
     tensor = b.create<ToTensorOp>(loc, shapedValue);
-  } else if (shapedValue.getType().isa<UnrankedTensorType>() ||
-             shapedValue.getType().isa<UnrankedMemRefType>()) {
+  } else if (llvm::isa<UnrankedTensorType>(shapedValue.getType()) ||
+             llvm::isa<UnrankedMemRefType>(shapedValue.getType())) {
     return getOwnerOfValue(shapedValue)
         ->emitError("copying of unranked tensors is not implemented");
   } else {
     llvm_unreachable("expected RankedTensorType or MemRefType");
   }
-  RankedTensorType tensorType = tensor.getType().cast<RankedTensorType>();
+  RankedTensorType tensorType = llvm::cast<RankedTensorType>(tensor.getType());
   SmallVector<Value> dynamicSizes;
   if (!copy) {
     // Compute the dynamic part of the shape.
     // First try to query the shape via ReifyRankedShapedTypeOpInterface.
     bool reifiedShapes = false;
-    if (shapedValue.getType().isa<RankedTensorType>() &&
-        shapedValue.isa<OpResult>()) {
+    if (llvm::isa<RankedTensorType>(shapedValue.getType()) &&
+        llvm::isa<OpResult>(shapedValue)) {
       ReifiedRankedShapedTypeDims resultDims;
       if (succeeded(
               reifyResultShapes(b, shapedValue.getDefiningOp(), resultDims))) {
         reifiedShapes = true;
         auto &shape =
-            resultDims[shapedValue.cast<OpResult>().getResultNumber()];
+            resultDims[llvm::cast<OpResult>(shapedValue).getResultNumber()];
         for (const auto &dim : enumerate(tensorType.getShape()))
           if (ShapedType::isDynamic(dim.value()))
             dynamicSizes.push_back(shape[dim.index()].get<Value>());
       }
     }
 
     // If the shape could not be reified, create DimOps.
     if (!reifiedShapes)
LogicalResult BufferizableOpInterface::resolveTensorOpOperandConflicts(
   DenseSet<OpOperand *> escapingOpOperandCopies;
   SmallVector<OpResult> outOfPlaceOpResults;
   DenseSet<OpResult> copiedOpResults;
   DenseSet<OpResult> escapingOpResultCopies;
 
   // Find all out-of-place OpOperands.
   for (OpOperand &opOperand : op->getOpOperands()) {
     Type operandType = opOperand.get().getType();
-    if (!operandType.isa<TensorType>())
+    if (!llvm::isa<TensorType>(operandType))
       continue;
     if (state.isInPlace(opOperand))
       continue;
-    if (operandType.isa<UnrankedTensorType>())
+    if (llvm::isa<UnrankedTensorType>(operandType))
       return op->emitError("copying of unranked tensors is not implemented");
 
     AliasingOpResultList aliasingOpResults =
         state.getAliasingOpResults(opOperand);
     // Is the result yielded from a block? Or are deallocations turned off
     // entirely? In either case, mark the allocation as "escaping", so that it
     // will not be deallocated.
     bool escape = !state.getOptions().createDeallocs ||
                   llvm::any_of(aliasingOpResults, [&](AliasingOpResult a) {
                     return state.isTensorYielded(a.opResult);
                   });
 
     if (aliasingOpResults.getNumAliases() == 1 &&
         !state.bufferizesToMemoryWrite(opOperand) &&
         state.getAliasingOpOperands(aliasingOpResults.getAliases()[0].opResult)
                 .getNumAliases() == 1 &&
-        !aliasingOpResults.getAliases()[0]
-             .opResult.getType()
-             .isa<UnrankedTensorType>()) {
+        !llvm::isa<UnrankedTensorType>(
+            aliasingOpResults.getAliases()[0].opResult.getType())) {
       // The op itself does not write but may create exactly one alias. Instead
       // of copying the OpOperand, copy the OpResult. The OpResult can sometimes
       // be smaller than the OpOperand (e.g., in the case of an extract_slice,
       // where the result is usually a smaller part of the source). Do not apply
       // this optimization if the OpResult is an unranked tensor (because those
       // cannot be copied at the moment).
       OpResult opResult = aliasingOpResults.getAliases()[0].opResult;
       outOfPlaceOpResults.push_back(opResult);
bool bufferization::shouldDeallocateOpResult(
     OpResult opResult, const BufferizationOptions &options) {
   Operation *op = opResult.getOwner();
   assert(options.dynCastBufferizableOp(op).bufferizesToAllocation(opResult) &&
          "expected that op allocates");
 
   AnalysisState analysisState(options);
   if (op->hasAttr(BufferizationDialect::kEscapeAttrName)) {
     // AllocTensorOp has one result.
-    ArrayAttr escapeAttr =
-        op->getAttr(BufferizationDialect::kEscapeAttrName).cast<ArrayAttr>();
-    return !escapeAttr[0].cast<BoolAttr>().getValue();
+    ArrayAttr escapeAttr = llvm::cast<ArrayAttr>(
+        op->getAttr(BufferizationDialect::kEscapeAttrName));
+    return !llvm::cast<BoolAttr>(escapeAttr[0]).getValue();
   }
 
   // No "escape" annotation found.
   if (options.createDeallocs) {
     // Perform an ad-hoc analysis.
     return !analysisState.isTensorYielded(opResult);
   }
 
defaultFunctionArgTypeConverter(TensorType type, Attribute memorySpace,
                                 func::FuncOp funcOp,
                                 const BufferizationOptions &options) {
   return getMemRefTypeWithFullyDynamicLayout(type, memorySpace);
 }
 /// Default unknown type converter: Use a fully dynamic layout map.
 BaseMemRefType
 defaultUnknownTypeConverter(Value value, Attribute memorySpace,
                             const BufferizationOptions &options) {
-  return getMemRefTypeWithFullyDynamicLayout(value.getType().cast<TensorType>(),
-                                             memorySpace);
+  return getMemRefTypeWithFullyDynamicLayout(
+      llvm::cast<TensorType>(value.getType()), memorySpace);
 }
 
 } // namespace
 
 // Default constructor for BufferizationOptions.
 BufferizationOptions::BufferizationOptions()
     : functionArgTypeConverterFn(defaultFunctionArgTypeConverter),
       unknownTypeConverterFn(defaultUnknownTypeConverter) {}
inferFunctionResultLayout =
       layoutMapOption == LayoutMapOption::InferLayoutMap;
 }
 
 //===----------------------------------------------------------------------===//
 // Helper functions for BufferizableOpInterface
 //===----------------------------------------------------------------------===//
 
 static void setInsertionPointAfter(OpBuilder &b, Value value) {
-  if (auto bbArg = value.dyn_cast<BlockArgument>()) {
+  if (auto bbArg = llvm::dyn_cast<BlockArgument>(value)) {
     b.setInsertionPointToStart(bbArg.getOwner());
   } else {
     b.setInsertionPointAfter(value.getDefiningOp());
   }
 }
 
 /// Determine which OpOperand* will alias with `opResult` if the op is
 /// bufferized in place. Return all tensor OpOperand* if the op is not
if (auto bufferizableOp =
     return bufferizableOp.bufferizesToAliasOnly(opOperand, *this);
 
   // Unknown op that returns a tensor. The inplace analysis does not support it.
   // Conservatively return false.
   return false;
 }
 
 bool AnalysisState::bufferizesToMemoryWrite(Value value) const {
-  auto opResult = value.dyn_cast<OpResult>();
+  auto opResult = llvm::dyn_cast<OpResult>(value);
   if (!opResult)
     return true;
   auto bufferizableOp = getOptions().dynCastBufferizableOp(value);
   if (!bufferizableOp)
     return true;
   return bufferizableOp.resultBufferizesToMemoryWrite(opResult, *this);
 }
 
 /// Return true if the given value is read by an op that bufferizes to a memory
 /// read. Also takes into account ops that create an alias but do not read by
 /// themselves (e.g., ExtractSliceOp).
 bool AnalysisState::isValueRead(Value value) const {
-  assert(value.getType().isa<TensorType>() && "expected TensorType");
+  assert(llvm::isa<TensorType>(value.getType()) && "expected TensorType");
   SmallVector<OpOperand *> workingSet;
   for (OpOperand &use : value.getUses())
     workingSet.push_back(&use);
 
   while (!workingSet.empty()) {
     OpOperand *uMaybeReading = workingSet.pop_back_val();
     // Skip over all ops that neither read nor write (but create an alias).
     if (bufferizesToAliasOnly(*uMaybeReading))
llvm::SetVector<Value> AnalysisState::findValueInReverseUseDefChain(
 
   while (!workingSet.empty()) {
     Value value = workingSet.pop_back_val();
     if (condition(value)) {
       result.insert(value);
       continue;
     }
 
-    if (value.isa<BlockArgument>()) {
+    if (llvm::isa<BlockArgument>(value)) {
       if (alwaysIncludeLeaves)
         result.insert(value);
       continue;
     }
 
-    OpResult opResult = value.cast<OpResult>();
+    OpResult opResult = llvm::cast<OpResult>(value);
     BufferizableOpInterface bufferizableOp =
         options.dynCastBufferizableOp(opResult.getDefiningOp());
     AliasingOpOperandList aliases = getAliasingOpOperands(opResult);
 
     // Stop iterating in either one of these cases:
     // * The current op is not bufferizable or excluded in the filter.
     // * There are no OpOperands to follow.
     if (!bufferizableOp || aliases.getNumAliases() == 0) {
bool AnalysisState::isTensorYielded(Value tensor) const {
 
   // No ReturnLike op found: The value is not yielded.
   return false;
 }
 
 // bufferization.to_memref is not allowed to change the rank.
 static void ensureToMemrefOpIsValid(Value tensor, Type memrefType) {
 #ifndef NDEBUG
-  auto rankedTensorType = tensor.getType().dyn_cast<RankedTensorType>();
-  assert((!rankedTensorType || memrefType.cast<MemRefType>().getRank() ==
+  auto rankedTensorType = llvm::dyn_cast<RankedTensorType>(tensor.getType());
+  assert((!rankedTensorType || llvm::cast<MemRefType>(memrefType).getRank() ==
                                    rankedTensorType.getRank()) &&
          "to_memref would be invalid: mismatching ranks");
 #endif
 }
 
 FailureOr<Value> bufferization::getBuffer(RewriterBase &rewriter, Value value,
                                           const BufferizationOptions &options) {
 #ifndef NDEBUG
-  auto tensorType = value.getType().dyn_cast<TensorType>();
+  auto tensorType = llvm::dyn_cast<TensorType>(value.getType());
   assert(tensorType && "unexpected non-tensor type");
 #endif // NDEBUG
 
   // Replace "%t = to_tensor %m" with %m.
   if (auto toTensorOp = value.getDefiningOp<bufferization::ToTensorOp>())
     return toTensorOp.getMemref();
 
   // Insert to_memref op.
bufferization::getBufferType(Value value, const BufferizationOptions &options) {
   DenseMap<Value, BaseMemRefType> fixedTypes;
   return getBufferType(value, options, fixedTypes);
 }
 
 /// Return the buffer type for a given Value (tensor) after bufferization.
 FailureOr<BaseMemRefType> bufferization::getBufferType(
     Value value, const BufferizationOptions &options,
     const DenseMap<Value, BaseMemRefType> &fixedTypes) {
-  assert(value.getType().isa<TensorType>() && "unexpected non-tensor type");
+  assert(llvm::isa<TensorType>(value.getType()) &&
+         "unexpected non-tensor type");
 
   // If the `value` is in `fixedTypes`, return the mapped type.
   const auto &it = fixedTypes.find(value);
   if (it != fixedTypes.end())
     return it->second;
 
   // Try querying BufferizableOpInterface.
   Operation *op = getOwnerOfValue(value);
void bufferization::replaceOpWithBufferizedValues(RewriterBase &rewriter,
   assert(values.size() == op->getNumResults() &&
          "expected one value per OpResult");
   OpBuilder::InsertionGuard g(rewriter);
 
   // Replace all OpResults with the given values.
   SmallVector<Value> replacements;
   for (OpResult opResult : op->getOpResults()) {
     Value replacement = values[opResult.getResultNumber()];
-    if (opResult.getType().isa<TensorType>()) {
+    if (llvm::isa<TensorType>(opResult.getType())) {
       // The OpResult is a tensor. Such values are replaced with memrefs during
       // bufferization.
-      assert((replacement.getType().isa<MemRefType>() ||
-              replacement.getType().isa<UnrankedMemRefType>()) &&
+      assert((llvm::isa<MemRefType>(replacement.getType()) ||
+              llvm::isa<UnrankedMemRefType>(replacement.getType())) &&
              "tensor op result should be replaced with a memref value");
       // The existing uses of the OpResult still expect a tensor. Insert a
       // ToTensorOp. Throughout bufferization, this ToTensorOp will gradually
       // loose all of its users and eventually DCE away.
       rewriter.setInsertionPointAfter(op);
       replacement = rewriter.create<bufferization::ToTensorOp>(
           replacement.getLoc(), replacement);
     }
LogicalResult BufferizationOptions::createMemCpy(OpBuilder &b, Location loc,
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Bufferization-specific IRMapping support with debugging.
 //===----------------------------------------------------------------------===//
 
 bool bufferization::isFunctionArgument(Value value) {
-  auto bbArg = value.dyn_cast<BlockArgument>();
+  auto bbArg = llvm::dyn_cast<BlockArgument>(value);
   if (!bbArg)
     return false;
   return isa<func::FuncOp>(bbArg.getOwner()->getParentOp());
 }
 
 BaseMemRefType bufferization::getMemRefType(Value value,
                                             const BufferizationOptions &options,
                                             MemRefLayoutAttrInterface layout,
                                             Attribute memorySpace) {
-  auto tensorType = value.getType().cast<TensorType>();
+  auto tensorType = llvm::cast<TensorType>(value.getType());
 
   // Case 1: Unranked memref type.
-  if (auto unrankedTensorType = tensorType.dyn_cast<UnrankedTensorType>()) {
+  if (auto unrankedTensorType =
+          llvm::dyn_cast<UnrankedTensorType>(tensorType)) {
     assert(!layout && "UnrankedTensorType cannot have a layout map");
     return UnrankedMemRefType::get(unrankedTensorType.getElementType(),
                                    memorySpace);
   }
 
   // Case 2: Ranked memref type with specified layout.
-  auto rankedTensorType = tensorType.cast<RankedTensorType>();
+  auto rankedTensorType = llvm::cast<RankedTensorType>(tensorType);
   if (layout) {
     return MemRefType::get(rankedTensorType.getShape(),
                            rankedTensorType.getElementType(), layout,
                            memorySpace);
   }
 
   return options.unknownTypeConverterFn(value, memorySpace, options);
 }
 
 BaseMemRefType
 bufferization::getMemRefTypeWithFullyDynamicLayout(TensorType tensorType,
                                                    Attribute memorySpace) {
   // Case 1: Unranked memref type.
-  if (auto unrankedTensorType = tensorType.dyn_cast<UnrankedTensorType>()) {
+  if (auto unrankedTensorType =
+          llvm::dyn_cast<UnrankedTensorType>(tensorType)) {
     return UnrankedMemRefType::get(unrankedTensorType.getElementType(),
                                    memorySpace);
   }
 
   // Case 2: Ranked memref type.
-  auto rankedTensorType = tensorType.cast<RankedTensorType>();
+  auto rankedTensorType = llvm::cast<RankedTensorType>(tensorType);
   int64_t dynamicOffset = ShapedType::kDynamic;
   SmallVector<int64_t> dynamicStrides(rankedTensorType.getRank(),
                                       ShapedType::kDynamic);
   auto stridedLayout = StridedLayoutAttr::get(tensorType.getContext(),
                                               dynamicOffset, dynamicStrides);
   return MemRefType::get(rankedTensorType.getShape(),
                          rankedTensorType.getElementType(), stridedLayout,
                          memorySpace);
 }
 
 /// Return a MemRef type with a static identity layout (i.e., no layout map). If
 /// the given tensor type is unranked, return an unranked MemRef type.
 BaseMemRefType
 bufferization::getMemRefTypeWithStaticIdentityLayout(TensorType tensorType,
                                                      Attribute memorySpace) {
   // Case 1: Unranked memref type.
-  if (auto unrankedTensorType = tensorType.dyn_cast<UnrankedTensorType>()) {
+  if (auto unrankedTensorType =
+          llvm::dyn_cast<UnrankedTensorType>(tensorType)) {
     return UnrankedMemRefType::get(unrankedTensorType.getElementType(),
                                    memorySpace);
   }
 
   // Case 2: Ranked memref type.
-  auto rankedTensorType = tensorType.cast<RankedTensorType>();
+  auto rankedTensorType = llvm::cast<RankedTensorType>(tensorType);
   MemRefLayoutAttrInterface layout = {};
   return MemRefType::get(rankedTensorType.getShape(),
                          rankedTensorType.getElementType(), layout,
                          memorySpace);
 }
 
 //===----------------------------------------------------------------------===//
 // Default implementations of interface methods

 
 // Compute the AliasingOpOperandList for a given OpResult based on
 // getAliasingOpResults.
 AliasingOpOperandList bufferization::detail::defaultGetAliasingOpOperands(
     OpResult opResult, const AnalysisState &state) {
   Operation *op = opResult.getDefiningOp();
   SmallVector<AliasingOpOperand> result;
   for (OpOperand &opOperand : op->getOpOperands()) {
-    if (!opOperand.get().getType().isa<TensorType>())
+    if (!llvm::isa<TensorType>(opOperand.get().getType()))
       continue;
     AliasingOpResultList aliasingOpResults =
         state.getAliasingOpResults(opOperand);
     for (const auto &it : aliasingOpResults)
       if (it.opResult == opResult)
         result.emplace_back(&opOperand, it.relation, it.isDefinite);
   }
   return AliasingOpOperandList(std::move(result));
 }
 
 FailureOr<BaseMemRefType> bufferization::detail::defaultGetBufferType(
     Value value, const BufferizationOptions &options,
     const DenseMap<Value, BaseMemRefType> &fixedTypes) {
-  assert(value.getType().isa<TensorType>() && "expected tensor type");
+  assert(llvm::isa<TensorType>(value.getType()) && "expected tensor type");
 
   // No further analysis is possible for a block argument.
-  if (value.isa<BlockArgument>())
+  if (llvm::isa<BlockArgument>(value))
     return bufferization::getMemRefType(value, options);
 
   // Value is an OpResult.
   Operation *op = getOwnerOfValue(value);
-  auto opResult = value.cast<OpResult>();
+  auto opResult = llvm::cast<OpResult>(value);
   AnalysisState state(options);
   AliasingOpOperandList aliases = state.getAliasingOpOperands(opResult);
   if (aliases.getNumAliases() > 0 &&
       aliases.getAliases()[0].relation == BufferRelation::Equivalent) {
     // If the OpResult has an equivalent OpOperand, both OpResult and
     // OpOperand bufferize to the exact same buffer type.
     Value equivalentOperand = aliases.getAliases().front().opOperand->get();
     return getBufferType(equivalentOperand, options, fixedTypes);
bool bufferization::detail::defaultIsRepetitiveRegion(
   return regionInterface.isRepetitiveRegion(index);
 }
 
 AliasingOpOperandList
 bufferization::detail::unknownGetAliasingOpOperands(OpResult opResult) {
   // Conservatively assume that everything may be aliasing.
   AliasingOpOperandList r;
   for (OpOperand &operand : opResult.getDefiningOp()->getOpOperands())
-    if (operand.get().getType().isa<TensorType>())
+    if (llvm::isa<TensorType>(operand.get().getType()))
       r.addAlias({&operand, BufferRelation::Unknown, /*isDefinite=*/false});
   return r;
 }
 
 AliasingOpResultList
 bufferization::detail::unknownGetAliasingOpResults(OpOperand &opOperand) {
   // Conservatively assume that everything may be aliasing.
   AliasingOpResultList r;
   for (OpResult result : opOperand.getOwner()->getOpResults())
-    if (result.getType().isa<TensorType>())
+    if (llvm::isa<TensorType>(result.getType()))
       r.addAlias({result, BufferRelation::Unknown, /*isDefinite=*/false});
   return r;
 }

mlir/lib/Dialect/Bufferization/IR/BufferizationDialect.cpp

#include "mlir/Dialect/Bufferization/IR/BufferizationOps.cpp.inc"
       >();
   addInterfaces<BufferizationInlinerInterface>();
 }
 
 LogicalResult BufferizationDialect::verifyRegionArgAttribute(
     Operation *op, unsigned /*regionIndex*/, unsigned argIndex,
     NamedAttribute attr) {
   if (attr.getName() == kWritableAttrName) {
-    if (!attr.getValue().isa<BoolAttr>()) {
+    if (!llvm::isa<BoolAttr>(attr.getValue())) {
       return op->emitError() << "'" << kWritableAttrName
                              << "' is expected to be a boolean attribute";
     }
     if (!isa<FunctionOpInterface>(op))
       return op->emitError() << "expected '" << kWritableAttrName
                              << "' to be used on function-like operations";
     if (cast<FunctionOpInterface>(op).isExternal())
       return op->emitError() << "'" << kWritableAttrName
                              << "' is invalid on external functions";
     return success();
   }
   if (attr.getName() == kBufferAccessAttrName) {
-    if (!attr.getValue().isa<StringAttr>()) {
+    if (!llvm::isa<StringAttr>(attr.getValue())) {
       return op->emitError() << "'" << kBufferAccessAttrName
                              << "' is expected to be a string attribute";
     }
-    StringRef str = attr.getValue().cast<StringAttr>().getValue();
+    StringRef str = llvm::cast<StringAttr>(attr.getValue()).getValue();
     if (str != "none" && str != "read" && str != "write" && str != "read-write")
       return op->emitError()
              << "invalid value for '" << kBufferAccessAttrName << "'";
     if (!isa<FunctionOpInterface>(op))
       return op->emitError() << "expected '" << kBufferAccessAttrName
                              << "' to be used on function-like operations";
     return success();
   }
   if (attr.getName() == kBufferLayoutAttrName) {
-    if (!attr.getValue().isa<AffineMapAttr>()) {
+    if (!llvm::isa<AffineMapAttr>(attr.getValue())) {
       return op->emitError() << "'" << kBufferLayoutAttrName
                              << "' is expected to be a affine map attribute";
     }
     if (!isa<FunctionOpInterface>(op))
       return op->emitError() << "expected '" << kBufferLayoutAttrName
                              << "' to be used on function-like operations";
     return success();
   }
   return op->emitError() << "attribute '" << kBufferLayoutAttrName
                          << "' not supported as a region arg attribute by the "
                             "bufferization dialect";
 }
 
 LogicalResult
 BufferizationDialect::verifyOperationAttribute(Operation *op,
                                                NamedAttribute attr) {
   using bufferization::BufferizableOpInterface;
 
   if (attr.getName() == kEscapeAttrName) {
-    auto arrayAttr = attr.getValue().dyn_cast<ArrayAttr>();
+    auto arrayAttr = llvm::dyn_cast<ArrayAttr>(attr.getValue());
     if (!arrayAttr)
       return op->emitError() << "'" << kEscapeAttrName
                              << "' is expected to be a bool array attribute";
     if (arrayAttr.size() != op->getNumResults())
       return op->emitError()
              << "'" << kEscapeAttrName
              << "' has wrong number of elements, expected "
              << op->getNumResults() << ", got " << arrayAttr.size();
     auto bufferizableOp = dyn_cast<BufferizableOpInterface>(op);
     if (!bufferizableOp)
       return op->emitError()
              << "'" << kEscapeAttrName << "' only valid on bufferizable ops";
     for (const auto &it : llvm::enumerate(arrayAttr)) {
       auto attr = it.value();
-      auto boolAttr = attr.dyn_cast<BoolAttr>();
+      auto boolAttr = llvm::dyn_cast<BoolAttr>(attr);
       if (!boolAttr)
         return op->emitError() << "'" << kEscapeAttrName
                                << "' is expected to be a bool array attribute";
       if (!boolAttr.getValue())
         continue;
-      if (!op->getResult(it.index()).getType().isa<TensorType>())
+      if (!llvm::isa<TensorType>(op->getResult(it.index()).getType()))
         return op->emitError()
                << "'" << kEscapeAttrName << "' only valid for tensor results";
       if (!bufferizableOp.bufferizesToAllocation(op->getOpResult(it.index())))
         return op->emitError() << "'" << kEscapeAttrName
                                << "' only valid for allocation results";
     }
     return success();
   }
 
   return op->emitError()
          << "attribute '" << attr.getName()
          << "' not supported as an op attribute by the bufferization dialect";
 }

mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp

 
 //===----------------------------------------------------------------------===//
 // Helper functions
 //===----------------------------------------------------------------------===//
 
 FailureOr<Value>
 mlir::bufferization::castOrReallocMemRefValue(OpBuilder &b, Value value,
                                               MemRefType destType) {
-  auto srcType = value.getType().cast<MemRefType>();
+  auto srcType = llvm::cast<MemRefType>(value.getType());
 
   // Element type, rank and memory space must match.
   if (srcType.getElementType() != destType.getElementType())
     return failure();
   if (srcType.getMemorySpace() != destType.getMemorySpace())
     return failure();
   if (srcType.getRank() != destType.getRank())
     return failure();
mlir::bufferization::foldToMemrefToTensorPair(RewriterBase &rewriter,
   Type destType = toMemref.getType();
 
   // Directly rewrite if the type did not change.
   if (srcType == destType) {
     rewriter.replaceOp(toMemref, memrefToTensor.getMemref());
     return success();
   }
 
-  auto rankedSrcType = srcType.dyn_cast<MemRefType>();
-  auto rankedDestType = destType.dyn_cast<MemRefType>();
-  auto unrankedSrcType = srcType.dyn_cast<UnrankedMemRefType>();
+  auto rankedSrcType = llvm::dyn_cast<MemRefType>(srcType);
+  auto rankedDestType = llvm::dyn_cast<MemRefType>(destType);
+  auto unrankedSrcType = llvm::dyn_cast<UnrankedMemRefType>(srcType);
 
   // Ranked memref -> Ranked memref cast.
   if (rankedSrcType && rankedDestType) {
     FailureOr<Value> replacement = castOrReallocMemRefValue(
         rewriter, memrefToTensor.getMemref(), rankedDestType);
     if (failed(replacement))
       return failure();
 
mlir::bufferization::foldToMemrefToTensorPair(RewriterBase &rewriter,
   rewriter.replaceOpWithNewOp<memref::CastOp>(toMemref, destType,
                                               memrefToTensor.getMemref());
   return success();
 }
 
 void mlir::bufferization::populateDynamicDimSizes(
     OpBuilder &b, Location loc, Value shapedValue,
     SmallVector<Value> &dynamicDims) {
-  auto shapedType = shapedValue.getType().cast<ShapedType>();
+  auto shapedType = llvm::cast<ShapedType>(shapedValue.getType());
   for (int64_t i = 0; i < shapedType.getRank(); ++i) {
     if (shapedType.isDynamicDim(i)) {
-      if (shapedType.isa<MemRefType>()) {
+      if (llvm::isa<MemRefType>(shapedType)) {
         dynamicDims.push_back(b.create<memref::DimOp>(loc, shapedValue, i));
       } else {
-        assert(shapedType.isa<RankedTensorType>() && "expected tensor");
+        assert(llvm::isa<RankedTensorType>(shapedType) && "expected tensor");
         dynamicDims.push_back(b.create<tensor::DimOp>(loc, shapedValue, i));
       }
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // AllocTensorOp
LogicalResult AllocTensorOp::bufferize(RewriterBase &rewriter,
   // Create memory copy (if any).
   if (getCopy()) {
     if (failed(options.createMemCpy(rewriter, loc, copyBuffer, *alloc)))
       return failure();
   }
 
   // Should the buffer be deallocated?
   bool dealloc =
-      shouldDeallocateOpResult(getResult().cast<OpResult>(), options);
+      shouldDeallocateOpResult(llvm::cast<OpResult>(getResult()), options);
 
   // Replace op.
   replaceOpWithBufferizedValues(rewriter, getOperation(), *alloc);
 
   // Create buffer deallocation (if requested).
   if (!dealloc)
     return success();
 
void AllocTensorOp::print(OpAsmPrinter &p) {
   if (getCopy())
     p << " copy(" << getCopy() << ")";
   if (getSizeHint())
     p << " size_hint=" << getSizeHint();
   p.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{
                               AllocTensorOp::getOperandSegmentSizeAttr()});
   p << " : ";
   auto type = getResult().getType();
-  if (auto validType = type.dyn_cast<::mlir::TensorType>())
+  if (auto validType = llvm::dyn_cast<::mlir::TensorType>(type))
     p.printStrippedAttrOrType(validType);
   else
     p << type;
 }
 
 Value AllocTensorOp::getDynamicSize(OpBuilder &b, unsigned idx) {
   assert(isDynamicDim(idx) && "expected dynamic dim");
   if (getCopy())
struct ToMemrefOfCast : public OpRewritePattern<ToMemrefOp> {
   using OpRewritePattern<ToMemrefOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(ToMemrefOp toMemref,
                                 PatternRewriter &rewriter) const final {
     auto tensorCastOperand =
         toMemref.getOperand().getDefiningOp<tensor::CastOp>();
     if (!tensorCastOperand)
       return failure();
-    auto srcTensorType =
-        tensorCastOperand.getOperand().getType().dyn_cast<RankedTensorType>();
+    auto srcTensorType = llvm::dyn_cast<RankedTensorType>(
+        tensorCastOperand.getOperand().getType());
     if (!srcTensorType)
       return failure();
     auto memrefType = MemRefType::get(srcTensorType.getShape(),
                                       srcTensorType.getElementType());
     Value memref = rewriter.create<ToMemrefOp>(toMemref.getLoc(), memrefType,
                                                tensorCastOperand.getOperand());
     rewriter.replaceOpWithNewOp<memref::CastOp>(toMemref, toMemref.getType(),
                                                 memref);

mlir/lib/Dialect/Complex/IR/ComplexDialect.cpp

 }
 
 Operation *complex::ComplexDialect::materializeConstant(OpBuilder &builder,
                                                         Attribute value,
                                                         Type type,
                                                         Location loc) {
   if (complex::ConstantOp::isBuildableWith(value, type)) {
     return builder.create<complex::ConstantOp>(loc, type,
-                                               value.cast<ArrayAttr>());
+                                               llvm::cast<ArrayAttr>(value));
   }
   return arith::ConstantOp::materialize(builder, value, type, loc);
 }
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/Complex/IR/ComplexAttributes.cpp.inc"
 
 LogicalResult complex::NumberAttr::verify(
     ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError,
     ::llvm::APFloat real, ::llvm::APFloat imag, ::mlir::Type type) {
 
-  if (!type.isa<ComplexType>())
+  if (!llvm::isa<ComplexType>(type))
     return emitError() << "complex attribute must be a complex type.";
 
-  Type elementType = type.cast<ComplexType>().getElementType();
-  if (!elementType.isa<FloatType>())
+  Type elementType = llvm::cast<ComplexType>(type).getElementType();
+  if (!llvm::isa<FloatType>(elementType))
     return emitError()
            << "element type of the complex attribute must be float like type.";
 
   const auto &typeFloatSemantics =
-      elementType.cast<FloatType>().getFloatSemantics();
+      llvm::cast<FloatType>(elementType).getFloatSemantics();
   if (&real.getSemantics() != &typeFloatSemantics)
     return emitError()
            << "type doesn't match the type implied by its `real` value";
   if (&imag.getSemantics() != &typeFloatSemantics)
     return emitError()
            << "type doesn't match the type implied by its `imag` value";
 
   return success();
 }
 
 void complex::NumberAttr::print(AsmPrinter &printer) const {
-  printer << "<:" << getType().cast<ComplexType>().getElementType() << " "
+  printer << "<:" << llvm::cast<ComplexType>(getType()).getElementType() << " "
           << getReal() << ", " << getImag() << ">";
 }
 
 Attribute complex::NumberAttr::parse(AsmParser &parser, Type odsType) {
   Type type;
   double real, imag;
   if (parser.parseLess() || parser.parseColon() || parser.parseType(type) ||
       parser.parseFloat(real) || parser.parseComma() ||
       parser.parseFloat(imag) || parser.parseGreater())
     return {};
 
   return NumberAttr::get(ComplexType::get(type), real, imag);
 }

mlir/lib/Dialect/Complex/IR/ComplexOps.cpp

 }
 
 void ConstantOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   setNameFn(getResult(), "cst");
 }
 
 bool ConstantOp::isBuildableWith(Attribute value, Type type) {
-  if (auto arrAttr = value.dyn_cast<ArrayAttr>()) {
-    auto complexTy = type.dyn_cast<ComplexType>();
+  if (auto arrAttr = llvm::dyn_cast<ArrayAttr>(value)) {
+    auto complexTy = llvm::dyn_cast<ComplexType>(type);
     if (!complexTy || arrAttr.size() != 2)
       return false;
     auto complexEltTy = complexTy.getElementType();
-    if (auto fre = arrAttr[0].dyn_cast<FloatAttr>()) {
-      auto im = arrAttr[1].dyn_cast<FloatAttr>();
+    if (auto fre = llvm::dyn_cast<FloatAttr>(arrAttr[0])) {
+      auto im = llvm::dyn_cast<FloatAttr>(arrAttr[1]);
       return im && fre.getType() == complexEltTy &&
              im.getType() == complexEltTy;
     }
-    if (auto ire = arrAttr[0].dyn_cast<IntegerAttr>()) {
-      auto im = arrAttr[1].dyn_cast<IntegerAttr>();
+    if (auto ire = llvm::dyn_cast<IntegerAttr>(arrAttr[0])) {
+      auto im = llvm::dyn_cast<IntegerAttr>(arrAttr[1]);
       return im && ire.getType() == complexEltTy &&
              im.getType() == complexEltTy;
     }
   }
   return false;
 }
 
 LogicalResult ConstantOp::verify() {
   ArrayAttr arrayAttr = getValue();
   if (arrayAttr.size() != 2) {
     return emitOpError(
         "requires 'value' to be a complex constant, represented as array of "
         "two values");
   }
 
   auto complexEltTy = getType().getElementType();
-  auto re = arrayAttr[0].dyn_cast<FloatAttr>();
-  auto im = arrayAttr[1].dyn_cast<FloatAttr>();
+  auto re = llvm::dyn_cast<FloatAttr>(arrayAttr[0]);
+  auto im = llvm::dyn_cast<FloatAttr>(arrayAttr[1]);
   if (!re || !im)
     return emitOpError("requires attribute's elements to be float attributes");
   if (complexEltTy != re.getType() || complexEltTy != im.getType()) {
     return emitOpError()
            << "requires attribute's element types (" << re.getType() << ", "
            << im.getType()
            << ") to match the element type of the op's return type ("
            << complexEltTy << ")";
OpFoldResult AddOp::fold(FoldAdaptor adaptor) {
   // complex.add(b, complex.sub(a, b)) -> a
   if (auto sub = getRhs().getDefiningOp<SubOp>())
     if (getLhs() == sub.getRhs())
       return sub.getLhs();
 
   // complex.add(a, complex.constant<0.0, 0.0>) -> a
   if (auto constantOp = getRhs().getDefiningOp<ConstantOp>()) {
     auto arrayAttr = constantOp.getValue();
-    if (arrayAttr[0].cast<FloatAttr>().getValue().isZero() &&
-        arrayAttr[1].cast<FloatAttr>().getValue().isZero()) {
+    if (llvm::cast<FloatAttr>(arrayAttr[0]).getValue().isZero() &&
+        llvm::cast<FloatAttr>(arrayAttr[1]).getValue().isZero()) {
       return getLhs();
     }
   }
 
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // SubOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult SubOp::fold(FoldAdaptor adaptor) {
   // complex.sub(complex.add(a, b), b) -> a
   if (auto add = getLhs().getDefiningOp<AddOp>())
     if (getRhs() == add.getRhs())
       return add.getLhs();
 
   // complex.sub(a, complex.constant<0.0, 0.0>) -> a
   if (auto constantOp = getRhs().getDefiningOp<ConstantOp>()) {
     auto arrayAttr = constantOp.getValue();
-    if (arrayAttr[0].cast<FloatAttr>().getValue().isZero() &&
-        arrayAttr[1].cast<FloatAttr>().getValue().isZero()) {
+    if (llvm::cast<FloatAttr>(arrayAttr[0]).getValue().isZero() &&
+        llvm::cast<FloatAttr>(arrayAttr[1]).getValue().isZero()) {
       return getLhs();
     }
   }
 
   return {};
 }
 
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/ControlFlow/IR/ControlFlowOps.cpp

static LogicalResult collapseBranch(Block *&successor,
   if (successor->args_empty()) {
     successor = successorDest;
     successorOperands = operands;
     return success();
   }
 
   // Otherwise, we need to remap any argument operands.
   for (Value operand : operands) {
-    BlockArgument argOperand = operand.dyn_cast<BlockArgument>();
+    BlockArgument argOperand = llvm::dyn_cast<BlockArgument>(operand);
     if (argOperand && argOperand.getOwner() == successor)
       argStorage.push_back(successorOperands[argOperand.getArgNumber()]);
     else
       argStorage.push_back(operand);
   }
   successor = successorDest;
   successorOperands = argStorage;
   return success();

 
 SuccessorOperands CondBranchOp::getSuccessorOperands(unsigned index) {
   assert(index < getNumSuccessors() && "invalid successor index");
   return SuccessorOperands(index == trueIndex ? getTrueDestOperandsMutable()
                                               : getFalseDestOperandsMutable());
 }
 
 Block *CondBranchOp::getSuccessorForOperands(ArrayRef<Attribute> operands) {
-  if (IntegerAttr condAttr = operands.front().dyn_cast_or_null<IntegerAttr>())
+  if (IntegerAttr condAttr =
+          llvm::dyn_cast_or_null<IntegerAttr>(operands.front()))
     return condAttr.getValue().isOne() ? getTrueDest() : getFalseDest();
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // SwitchOp
 //===----------------------------------------------------------------------===//
 

 
 Block *SwitchOp::getSuccessorForOperands(ArrayRef<Attribute> operands) {
   std::optional<DenseIntElementsAttr> caseValues = getCaseValues();
 
   if (!caseValues)
     return getDefaultDestination();
 
   SuccessorRange caseDests = getCaseDestinations();
-  if (auto value = operands.front().dyn_cast_or_null<IntegerAttr>()) {
+  if (auto value = llvm::dyn_cast_or_null<IntegerAttr>(operands.front())) {
     for (const auto &it : llvm::enumerate(caseValues->getValues<APInt>()))
       if (it.value() == value.getValue())
         return caseDests[it.index()];
     return getDefaultDestination();
   }
   return nullptr;
 }
 

mlir/lib/Dialect/DLTI/DLTI.cpp

if (!entriesForType.count(kvp.first)) {
       continue;
     }
 
     Type typeSample = kvp.second.front().getKey().get<Type>();
     assert(&typeSample.getDialect() !=
                typeSample.getContext()->getLoadedDialect<BuiltinDialect>() &&
            "unexpected data layout entry for built-in type");
 
-    auto interface = typeSample.cast<DataLayoutTypeInterface>();
+    auto interface = llvm::cast<DataLayoutTypeInterface>(typeSample);
     if (!interface.areCompatible(entriesForType.lookup(kvp.first), kvp.second))
       return failure();
 
     overwriteDuplicateEntries(entriesForType[kvp.first], kvp.second);
   }
 
   for (const auto &kvp : newEntriesForID) {
     StringAttr id = kvp.second.getKey().get<StringAttr>();
combineOneSpec(DataLayoutSpecInterface spec,
   return success();
 }
 
 DataLayoutSpecAttr
 DataLayoutSpecAttr::combineWith(ArrayRef<DataLayoutSpecInterface> specs) const {
   // Only combine with attributes of the same kind.
   // TODO: reconsider this when the need arises.
   if (llvm::any_of(specs, [](DataLayoutSpecInterface spec) {
-        return !spec.isa<DataLayoutSpecAttr>();
+        return !llvm::isa<DataLayoutSpecAttr>(spec);
       }))
     return {};
 
   // Combine all specs in order, with `this` being the last one.
   DenseMap<TypeID, DataLayoutEntryList> entriesForType;
   DenseMap<StringAttr, DataLayoutEntryInterface> entriesForID;
   for (DataLayoutSpecInterface spec : specs)
     if (failed(combineOneSpec(spec, entriesForType, entriesForID)))

 class TargetDataLayoutInterface : public DataLayoutDialectInterface {
 public:
   using DataLayoutDialectInterface::DataLayoutDialectInterface;
 
   LogicalResult verifyEntry(DataLayoutEntryInterface entry,
                             Location loc) const final {
     StringRef entryName = entry.getKey().get<StringAttr>().strref();
     if (entryName == DLTIDialect::kDataLayoutEndiannessKey) {
-      auto value = entry.getValue().dyn_cast<StringAttr>();
+      auto value = llvm::dyn_cast<StringAttr>(entry.getValue());
       if (value &&
           (value.getValue() == DLTIDialect::kDataLayoutEndiannessBig ||
            value.getValue() == DLTIDialect::kDataLayoutEndiannessLittle))
         return success();
       return emitError(loc) << "'" << entryName
                             << "' data layout entry is expected to be either '"
                             << DLTIDialect::kDataLayoutEndiannessBig << "' or '"
                             << DLTIDialect::kDataLayoutEndiannessLittle << "'";
llvm::TypeSwitch<Attribute>(attr)
       .Case<DataLayoutEntryAttr, DataLayoutSpecAttr>(
           [&](auto a) { a.print(os); })
       .Default([](Attribute) { llvm_unreachable("unknown attribute kind"); });
 }
 
 LogicalResult DLTIDialect::verifyOperationAttribute(Operation *op,
                                                     NamedAttribute attr) {
   if (attr.getName() == DLTIDialect::kDataLayoutAttrName) {
-    if (!attr.getValue().isa<DataLayoutSpecAttr>()) {
+    if (!llvm::isa<DataLayoutSpecAttr>(attr.getValue())) {
       return op->emitError() << "'" << DLTIDialect::kDataLayoutAttrName
                              << "' is expected to be a #dlti.dl_spec attribute";
     }
     if (isa<ModuleOp>(op))
       return detail::verifyDataLayoutOp(op);
     return success();
   }
 
   return op->emitError() << "attribute '" << attr.getName().getValue()
                          << "' not supported by dialect";
 }

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

 
 //===----------------------------------------------------------------------===//
 // CastOp
 //===----------------------------------------------------------------------===//
 
 bool CastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   Type input = inputs.front(), output = outputs.front();
 
-  return ((input.isa<IntegerType, FloatType, IndexType, emitc::OpaqueType,
-                     emitc::PointerType>()) &&
-          (output.isa<IntegerType, FloatType, IndexType, emitc::OpaqueType,
-                      emitc::PointerType>()));
+  return ((llvm::isa<IntegerType, FloatType, IndexType, emitc::OpaqueType,
+                     emitc::PointerType>(input)) &&
+          (llvm::isa<IntegerType, FloatType, IndexType, emitc::OpaqueType,
+                     emitc::PointerType>(output)));
 }
 
 //===----------------------------------------------------------------------===//
 // CallOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult emitc::CallOp::verify() {
   // Callee must not be empty.
   if (getCallee().empty())
     return emitOpError("callee must not be empty");
 
   if (std::optional<ArrayAttr> argsAttr = getArgs()) {
     for (Attribute arg : *argsAttr) {
-      auto intAttr = arg.dyn_cast<IntegerAttr>();
-      if (intAttr && intAttr.getType().isa<IndexType>()) {
+      auto intAttr = llvm::dyn_cast<IntegerAttr>(arg);
+      if (intAttr && llvm::isa<IndexType>(intAttr.getType())) {
         int64_t index = intAttr.getInt();
         // Args with elements of type index must be in range
         // [0..operands.size).
         if ((index < 0) || (index >= static_cast<int64_t>(getNumOperands())))
           return emitOpError("index argument is out of range");
 
         // Args with elements of type ArrayAttr must have a type.
-      } else if (arg.isa<ArrayAttr>() /*&& arg.getType().isa<NoneType>()*/) {
+      } else if (llvm::isa<ArrayAttr>(
+                     arg) /*&& arg.getType().isa<NoneType>()*/) {
         // FIXME: Array attributes never have types
         return emitOpError("array argument has no type");
       }
     }
   }
 
   if (std::optional<ArrayAttr> templateArgsAttr = getTemplateArgs()) {
     for (Attribute tArg : *templateArgsAttr) {
-      if (!tArg.isa<TypeAttr, IntegerAttr, FloatAttr, emitc::OpaqueAttr>())
+      if (!llvm::isa<TypeAttr, IntegerAttr, FloatAttr, emitc::OpaqueAttr>(tArg))
         return emitOpError("template argument has invalid type");
     }
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 /// The constant op requires that the attribute's type matches the return type.
 LogicalResult emitc::ConstantOp::verify() {
-  if (getValueAttr().isa<emitc::OpaqueAttr>())
+  if (llvm::isa<emitc::OpaqueAttr>(getValueAttr()))
     return success();
 
   // Value must not be empty
-  StringAttr strAttr = getValueAttr().dyn_cast<StringAttr>();
+  StringAttr strAttr = llvm::dyn_cast<StringAttr>(getValueAttr());
   if (strAttr && strAttr.getValue().empty())
     return emitOpError() << "value must not be empty";
 
   auto value = cast<TypedAttr>(getValueAttr());
   Type type = getType();
-  if (!value.getType().isa<NoneType>() && type != value.getType())
+  if (!llvm::isa<NoneType>(value.getType()) && type != value.getType())
     return emitOpError() << "requires attribute's type (" << value.getType()
                          << ") to match op's return type (" << type << ")";
   return success();
 }
 
 OpFoldResult emitc::ConstantOp::fold(FoldAdaptor adaptor) {
   return getValue();
 }

 }
 
 //===----------------------------------------------------------------------===//
 // VariableOp
 //===----------------------------------------------------------------------===//
 
 /// The variable op requires that the attribute's type matches the return type.
 LogicalResult emitc::VariableOp::verify() {
-  if (getValueAttr().isa<emitc::OpaqueAttr>())
+  if (llvm::isa<emitc::OpaqueAttr>(getValueAttr()))
     return success();
 
   auto value = cast<TypedAttr>(getValueAttr());
   Type type = getType();
-  if (!value.getType().isa<NoneType>() && type != value.getType())
+  if (!llvm::isa<NoneType>(value.getType()) && type != value.getType())
     return emitOpError() << "requires attribute's type (" << value.getType()
                          << ") to match op's return type (" << type << ")";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/Func/IR/FuncOps.cpp

 }
 
 /// Materialize a single constant operation from a given attribute value with
 /// the desired resultant type.
 Operation *FuncDialect::materializeConstant(OpBuilder &builder, Attribute value,
                                             Type type, Location loc) {
   if (ConstantOp::isBuildableWith(value, type))
     return builder.create<ConstantOp>(loc, type,
-                                      value.cast<FlatSymbolRefAttr>());
+                                      llvm::cast<FlatSymbolRefAttr>(value));
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // CallOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult CallOp::verifySymbolUses(SymbolTableCollection &symbolTable) {

 }
 
 void ConstantOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   setNameFn(getResult(), "f");
 }
 
 bool ConstantOp::isBuildableWith(Attribute value, Type type) {
-  return value.isa<FlatSymbolRefAttr>() && type.isa<FunctionType>();
+  return llvm::isa<FlatSymbolRefAttr>(value) && llvm::isa<FunctionType>(type);
 }
 
 //===----------------------------------------------------------------------===//
 // FuncOp
 //===----------------------------------------------------------------------===//
 
 FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
                       ArrayRef<NamedAttribute> attrs) {

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

TypeSwitch<Type>(type)
         os << shape.back() << 'x' << fragTy.getElementType();
         os << ", \"" << fragTy.getOperand() << "\"" << '>';
       })
       .Default([](Type) { llvm_unreachable("unexpected 'gpu' type kind"); });
 }
 
 LogicalResult GPUDialect::verifyOperationAttribute(Operation *op,
                                                    NamedAttribute attr) {
-  if (!attr.getValue().isa<UnitAttr>() ||
+  if (!llvm::isa<UnitAttr>(attr.getValue()) ||
       attr.getName() != getContainerModuleAttrName())
     return success();
 
   auto module = dyn_cast<ModuleOp>(op);
   if (!module)
     return op->emitError("expected '")
            << getContainerModuleAttrName() << "' attribute to be attached to '"
            << ModuleOp::getOperationName() << '\'';
static void printAttributions(OpAsmPrinter &p, StringRef keyword,
   p << ')';
 }
 
 /// Verifies a GPU function memory attribution.
 static LogicalResult verifyAttributions(Operation *op,
                                         ArrayRef<BlockArgument> attributions,
                                         gpu::AddressSpace memorySpace) {
   for (Value v : attributions) {
-    auto type = v.getType().dyn_cast<MemRefType>();
+    auto type = llvm::dyn_cast<MemRefType>(v.getType());
     if (!type)
       return op->emitOpError() << "expected memref type in attribution";
 
     // We can only verify the address space if it hasn't already been lowered
     // from the AddressSpaceAttr to a target-specific numeric value.
     auto addressSpace =
-        type.getMemorySpace().dyn_cast_or_null<gpu::AddressSpaceAttr>();
+        llvm::dyn_cast_or_null<gpu::AddressSpaceAttr>(type.getMemorySpace());
     if (!addressSpace)
       continue;
     if (addressSpace.getValue() != memorySpace)
       return op->emitOpError()
              << "expected memory space " << stringifyAddressSpace(memorySpace)
              << " in attribution";
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // AllReduceOp
 //===----------------------------------------------------------------------===//
 
 static bool verifyReduceOpAndType(gpu::AllReduceOperation opName,
                                   Type resType) {
   return (opName != gpu::AllReduceOperation::AND &&
           opName != gpu::AllReduceOperation::OR &&
           opName != gpu::AllReduceOperation::XOR) ||
-         resType.isa<IntegerType>();
+         llvm::isa<IntegerType>(resType);
 }
 
 LogicalResult gpu::AllReduceOp::verifyRegions() {
   if (getBody().empty() != getOp().has_value())
     return emitError("expected either an op attribute or a non-empty body");
   if (!getBody().empty()) {
     if (getBody().getNumArguments() != 2)
       return emitError("expected two region arguments");
static void printAttributions(OpAsmPrinter &p, StringRef keyword,
   llvm::interleaveComma(
       llvm::enumerate(values), p, [&p, attributes](auto pair) {
         BlockArgument v = pair.value();
         p << v << " : " << v.getType();
 
         size_t attributionIndex = pair.index();
         DictionaryAttr attrs;
         if (attributes && attributionIndex < attributes.size())
-          attrs = attributes[attributionIndex].cast<DictionaryAttr>();
+          attrs = llvm::cast<DictionaryAttr>(attributes[attributionIndex]);
         if (attrs)
           p.printOptionalAttrDict(attrs.getValue());
       });
   p << ')';
 }
 
 void GPUFuncOp::print(OpAsmPrinter &p) {
   p << ' ';
function_interface_impl::printFunctionAttributes(
        getArgAttrsAttrName(), getResAttrsAttrName(),
        getWorkgroupAttribAttrsAttrName(), getPrivateAttribAttrsAttrName()});
   p << ' ';
   p.printRegion(getBody(), /*printEntryBlockArgs=*/false);
 }
 
 static DictionaryAttr getAttributionAttrs(GPUFuncOp op, unsigned index,
                                           StringAttr attrName) {
-  auto allAttrs = op->getAttr(attrName).dyn_cast_or_null<ArrayAttr>();
+  auto allAttrs = llvm::dyn_cast_or_null<ArrayAttr>(op->getAttr(attrName));
   if (!allAttrs || index >= allAttrs.size())
     return DictionaryAttr();
-  return allAttrs[index].cast<DictionaryAttr>();
+  return llvm::cast<DictionaryAttr>(allAttrs[index]);
 }
 
 DictionaryAttr GPUFuncOp::getworkgroupAttributionAttrs(unsigned index) {
   return getAttributionAttrs(*this, index, getWorkgroupAttribAttrsAttrName());
 }
 
 DictionaryAttr GPUFuncOp::getPrivateAttributionAttrs(unsigned index) {
   return getAttributionAttrs(*this, index, getPrivateAttribAttrsAttrName());
 }
 
 static void setAttributionAttrs(GPUFuncOp op, unsigned index,
                                 DictionaryAttr value, StringAttr attrName) {
   MLIRContext *ctx = op.getContext();
-  auto allAttrs = op->getAttr(attrName).dyn_cast_or_null<ArrayAttr>();
+  auto allAttrs = llvm::dyn_cast_or_null<ArrayAttr>(op->getAttr(attrName));
   SmallVector<Attribute> elements;
   if (allAttrs)
     elements.append(allAttrs.begin(), allAttrs.end());
   while (elements.size() <= index)
     elements.push_back(DictionaryAttr::get(ctx));
   if (!value)
     elements[index] = DictionaryAttr::get(ctx);
   else
LogicalResult GPUFuncOp::verifyBody() {
   return success();
 }
 
 static LogicalResult verifyKnownLaunchSizeAttr(gpu::GPUFuncOp op,
                                                StringRef attrName) {
   auto maybeAttr = op->getAttr(attrName);
   if (!maybeAttr)
     return success();
-  auto array = maybeAttr.dyn_cast<DenseI32ArrayAttr>();
+  auto array = llvm::dyn_cast<DenseI32ArrayAttr>(maybeAttr);
   if (!array)
     return op.emitOpError(attrName + " must be a dense i32 array");
   if (array.size() != 3)
     return op.emitOpError(attrName + " must contain exactly 3 elements");
   return success();
 }
 
 LogicalResult GPUFuncOp::verify() {
if (failed(getStridesAndOffset(type, strides, offset))) {
     return false;
   }
   return strides.back() == 1;
 }
 
 LogicalResult SubgroupMmaLoadMatrixOp::verify() {
   auto srcType = getSrcMemref().getType();
   auto resType = getRes().getType();
-  auto resMatrixType = resType.cast<gpu::MMAMatrixType>();
+  auto resMatrixType = llvm::cast<gpu::MMAMatrixType>(resType);
   auto operand = resMatrixType.getOperand();
-  auto srcMemrefType = srcType.cast<MemRefType>();
+  auto srcMemrefType = llvm::cast<MemRefType>(srcType);
 
   if (!isLastMemrefDimUnitStride(srcMemrefType))
     return emitError(
         "expected source memref most minor dim must have unit stride");
 
   if (!operand.equals("AOp") && !operand.equals("BOp") &&
       !operand.equals("COp"))
     return emitError("only AOp, BOp and COp can be loaded");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // GPU_SubgroupMmaStoreMatrixOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult SubgroupMmaStoreMatrixOp::verify() {
   auto srcType = getSrc().getType();
   auto dstType = getDstMemref().getType();
-  auto srcMatrixType = srcType.cast<gpu::MMAMatrixType>();
-  auto dstMemrefType = dstType.cast<MemRefType>();
+  auto srcMatrixType = llvm::cast<gpu::MMAMatrixType>(srcType);
+  auto dstMemrefType = llvm::cast<MemRefType>(dstType);
 
   if (!isLastMemrefDimUnitStride(dstMemrefType))
     return emitError(
         "expected destination memref most minor dim must have unit stride");
 
   if (!srcMatrixType.getOperand().equals("COp"))
     return emitError(
         "expected the operand matrix being stored to have 'COp' operand type");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // GPU_SubgroupMmaComputeOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult SubgroupMmaComputeOp::verify() {
   enum OperandMap { A, B, C };
   SmallVector<MMAMatrixType, 3> opTypes;
-  opTypes.push_back(getOpA().getType().cast<MMAMatrixType>());
-  opTypes.push_back(getOpB().getType().cast<MMAMatrixType>());
-  opTypes.push_back(getOpC().getType().cast<MMAMatrixType>());
+  opTypes.push_back(llvm::cast<MMAMatrixType>(getOpA().getType()));
+  opTypes.push_back(llvm::cast<MMAMatrixType>(getOpB().getType()));
+  opTypes.push_back(llvm::cast<MMAMatrixType>(getOpC().getType()));
 
   if (!opTypes[A].getOperand().equals("AOp") ||
       !opTypes[B].getOperand().equals("BOp") ||
       !opTypes[C].getOperand().equals("COp"))
     return emitError("operands must be in the order AOp, BOp, COp");
 
   ArrayRef<int64_t> aShape, bShape, cShape;
   aShape = opTypes[A].getShape();
void WaitOp::getCanonicalizationPatterns(RewritePatternSet &results,
   results.add<EraseRedundantGpuWaitOpPairs, SimplifyGpuWaitOp>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // GPU_AllocOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult AllocOp::verify() {
-  auto memRefType = getMemref().getType().cast<MemRefType>();
+  auto memRefType = llvm::cast<MemRefType>(getMemref().getType());
 
   if (static_cast<int64_t>(getDynamicSizes().size()) !=
       memRefType.getNumDynamicDims())
     return emitOpError("dimension operand count does not equal memref "
                        "dynamic dimension count");
 
   unsigned numSymbols = 0;
   if (!memRefType.getLayout().isIdentity())
struct SimplifyDimOfAllocOp : public OpRewritePattern<memref::DimOp> {
   using OpRewritePattern<memref::DimOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(memref::DimOp dimOp,
                                 PatternRewriter &rewriter) const override {
     auto index = dimOp.getIndex().getDefiningOp<arith::ConstantIndexOp>();
     if (!index)
       return failure();
 
-    auto memrefType = dimOp.getSource().getType().dyn_cast<MemRefType>();
+    auto memrefType = llvm::dyn_cast<MemRefType>(dimOp.getSource().getType());
     if (!memrefType || !memrefType.isDynamicDim(index.value()))
       return failure();
 
     auto alloc = dimOp.getSource().getDefiningOp<AllocOp>();
     if (!alloc)
       return failure();
 
     Value substituteOp = *(alloc.getDynamicSizes().begin() +

mlir/lib/Dialect/Index/IR/IndexOps.cpp

Operation *IndexDialect::materializeConstant(OpBuilder &b, Attribute value,
   if (auto boolValue = dyn_cast<BoolAttr>(value)) {
     if (!type.isSignlessInteger(1))
       return nullptr;
     return b.create<BoolConstantOp>(loc, type, boolValue);
   }
 
   // Materialize integer attributes as `index`.
   if (auto indexValue = dyn_cast<IntegerAttr>(value)) {
-    if (!indexValue.getType().isa<IndexType>() || !type.isa<IndexType>())
+    if (!llvm::isa<IndexType>(indexValue.getType()) ||
+        !llvm::isa<IndexType>(type))
       return nullptr;
     assert(indexValue.getValue().getBitWidth() ==
            IndexType::kInternalStorageBitWidth);
     return b.create<ConstantOp>(loc, indexValue);
   }
 
   return nullptr;
 }
return foldBinaryOpUnchecked(
       [](const APInt &lhs, const APInt &rhs) { return lhs ^ rhs; });
 }
 
 //===----------------------------------------------------------------------===//
 // CastSOp
 //===----------------------------------------------------------------------===//
 
 bool CastSOp::areCastCompatible(TypeRange lhsTypes, TypeRange rhsTypes) {
-  return lhsTypes.front().isa<IndexType>() != rhsTypes.front().isa<IndexType>();
+  return llvm::isa<IndexType>(lhsTypes.front()) !=
+         llvm::isa<IndexType>(rhsTypes.front());
 }
 
 //===----------------------------------------------------------------------===//
 // CastUOp
 //===----------------------------------------------------------------------===//
 
 bool CastUOp::areCastCompatible(TypeRange lhsTypes, TypeRange rhsTypes) {
-  return lhsTypes.front().isa<IndexType>() != rhsTypes.front().isa<IndexType>();
+  return llvm::isa<IndexType>(lhsTypes.front()) !=
+         llvm::isa<IndexType>(rhsTypes.front());
 }
 
 //===----------------------------------------------------------------------===//
 // CmpOp
 //===----------------------------------------------------------------------===//
 
 /// Compare two integers according to the comparison predicate.
 bool compareIndices(const APInt &lhs, const APInt &rhs,

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

ParseResult FCmpOp::parse(OpAsmParser &parser, OperationState &result) {
   return parseCmpOp<FCmpPredicate>(parser, result);
 }
 
 //===----------------------------------------------------------------------===//
 // Printing, parsing and verification for LLVM::AllocaOp.
 //===----------------------------------------------------------------------===//
 
 void AllocaOp::print(OpAsmPrinter &p) {
-  Type elemTy = getType().cast<LLVM::LLVMPointerType>().getElementType();
+  Type elemTy = llvm::cast<LLVM::LLVMPointerType>(getType()).getElementType();
   if (!elemTy)
     elemTy = *getElemType();
 
   auto funcTy =
       FunctionType::get(getContext(), {getArraySize().getType()}, {getType()});
 
   if (getInalloca())
     p << " inalloca";
if (parser.parseOperand(arraySize) || parser.parseKeyword("x") ||
       parser.parseType(elemType) ||
       parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
       parser.getCurrentLocation(&trailingTypeLoc) || parser.parseType(type))
     return failure();
 
   std::optional<NamedAttribute> alignmentAttr =
       result.attributes.getNamed("alignment");
   if (alignmentAttr.has_value()) {
-    auto alignmentInt = alignmentAttr->getValue().dyn_cast<IntegerAttr>();
+    auto alignmentInt = llvm::dyn_cast<IntegerAttr>(alignmentAttr->getValue());
     if (!alignmentInt)
       return parser.emitError(parser.getNameLoc(),
                               "expected integer alignment");
     if (alignmentInt.getValue().isZero())
       result.attributes.erase("alignment");
   }
 
   // Extract the result type from the trailing function type.
-  auto funcType = type.dyn_cast<FunctionType>();
+  auto funcType = llvm::dyn_cast<FunctionType>(type);
   if (!funcType || funcType.getNumInputs() != 1 ||
       funcType.getNumResults() != 1)
     return parser.emitError(
         trailingTypeLoc,
         "expected trailing function type with one argument and one result");
 
   if (parser.resolveOperand(arraySize, funcType.getInput(0), result.operands))
     return failure();
 
   Type resultType = funcType.getResult(0);
-  if (auto ptrResultType = resultType.dyn_cast<LLVMPointerType>()) {
+  if (auto ptrResultType = llvm::dyn_cast<LLVMPointerType>(resultType)) {
     if (ptrResultType.isOpaque())
       result.addAttribute(kElemTypeAttrName, TypeAttr::get(elemType));
   }
 
   result.addTypes({funcType.getResult(0)});
   return success();
 }
 
if (!ptrType.isOpaque() && ptrElementType.has_value()) {
     return op->emitOpError()
            << "unexpected '" << kElemTypeAttrName
            << "' attribute when non-opaque pointer type is used";
   }
   return success();
 }
 
 LogicalResult AllocaOp::verify() {
-  return verifyOpaquePtr(getOperation(), getType().cast<LLVMPointerType>(),
+  return verifyOpaquePtr(getOperation(), llvm::cast<LLVMPointerType>(getType()),
                          getElemType());
 }
 
 //===----------------------------------------------------------------------===//
 // LLVM::BrOp
 //===----------------------------------------------------------------------===//
 
 /// Check if the `loopAttr` references correct symbols.
static void printSwitchOpCases(OpAsmPrinter &p, SwitchOp op, Type flagType,
                                SuccessorRange caseDestinations,
                                OperandRangeRange caseOperands,
                                const TypeRangeRange &caseOperandTypes) {
   if (!caseValues)
     return;
 
   size_t index = 0;
   llvm::interleave(
-      llvm::zip(caseValues.cast<DenseIntElementsAttr>(), caseDestinations),
+      llvm::zip(llvm::cast<DenseIntElementsAttr>(caseValues), caseDestinations),
       [&](auto i) {
         p << "  ";
         p << std::get<0>(i).getLimitedValue();
         p << ": ";
         p.printSuccessorAndUseList(std::get<1>(i), caseOperands[index++]);
       },
       [&] {
         p << ',';

 
 GEPIndicesAdaptor<ValueRange> GEPOp::getIndices() {
   return GEPIndicesAdaptor<ValueRange>(getRawConstantIndicesAttr(),
                                        getDynamicIndices());
 }
 
 /// Returns the elemental type of any LLVM-compatible vector type or self.
 static Type extractVectorElementType(Type type) {
-  if (auto vectorType = type.dyn_cast<VectorType>())
+  if (auto vectorType = llvm::dyn_cast<VectorType>(type))
     return vectorType.getElementType();
-  if (auto scalableVectorType = type.dyn_cast<LLVMScalableVectorType>())
+  if (auto scalableVectorType = llvm::dyn_cast<LLVMScalableVectorType>(type))
     return scalableVectorType.getElementType();
-  if (auto fixedVectorType = type.dyn_cast<LLVMFixedVectorType>())
+  if (auto fixedVectorType = llvm::dyn_cast<LLVMFixedVectorType>(type))
     return fixedVectorType.getElementType();
   return type;
 }
 
 void GEPOp::build(OpBuilder &builder, OperationState &result, Type resultType,
                   Value basePtr, ArrayRef<GEPArg> indices, bool inbounds,
                   ArrayRef<NamedAttribute> attributes) {
   auto ptrType =
-      extractVectorElementType(basePtr.getType()).cast<LLVMPointerType>();
+      llvm::cast<LLVMPointerType>(extractVectorElementType(basePtr.getType()));
   assert(!ptrType.isOpaque() &&
          "expected non-opaque pointer, provide elementType explicitly when "
          "opaque pointers are used");
   build(builder, result, resultType, ptrType.getElementType(), basePtr, indices,
         inbounds, attributes);
 }
 
 /// Destructures the 'indices' parameter into 'rawConstantIndices' and
void GEPOp::build(OpBuilder &builder, OperationState &result, Type resultType,
   result.addTypes(resultType);
   result.addAttributes(attributes);
   result.addAttribute(getRawConstantIndicesAttrName(result.name),
                       builder.getDenseI32ArrayAttr(rawConstantIndices));
   if (inbounds) {
     result.addAttribute(getInboundsAttrName(result.name),
                         builder.getUnitAttr());
   }
-  if (extractVectorElementType(basePtr.getType())
-          .cast<LLVMPointerType>()
+  if (llvm::cast<LLVMPointerType>(extractVectorElementType(basePtr.getType()))
           .isOpaque())
     result.addAttribute(kElemTypeAttrName, TypeAttr::get(elementType));
   result.addOperands(basePtr);
   result.addOperands(dynamicIndices);
 }
 
 void GEPOp::build(OpBuilder &builder, OperationState &result, Type resultType,
                   Value basePtr, ValueRange indices, bool inbounds,

 static llvm::Error verifyStructIndices(Type baseGEPType,
                                        GEPIndicesAdaptor<ValueRange> indices) {
   return verifyStructIndices(baseGEPType, /*indexPos=*/1, indices);
 }
 
 LogicalResult LLVM::GEPOp::verify() {
   if (failed(verifyOpaquePtr(
           getOperation(),
-          extractVectorElementType(getType()).cast<LLVMPointerType>(),
+          llvm::cast<LLVMPointerType>(extractVectorElementType(getType())),
           getElemType())))
     return failure();
 
   if (static_cast<size_t>(
           llvm::count(getRawConstantIndices(), kDynamicIndex)) !=
       getDynamicIndices().size())
     return emitOpError("expected as many dynamic indices as specified in '")
            << getRawConstantIndicesAttrName().getValue() << "'";
 
   if (llvm::Error err =
           verifyStructIndices(getSourceElementType(), getIndices()))
     return emitOpError() << llvm::toString(std::move(err));
 
   return success();
 }
 
 Type LLVM::GEPOp::getSourceElementType() {
   if (std::optional<Type> elemType = getElemType())
     return *elemType;
 
-  return extractVectorElementType(getBase().getType())
-      .cast<LLVMPointerType>()
+  return llvm::cast<LLVMPointerType>(
+             extractVectorElementType(getBase().getType()))
       .getElementType();
 }
 
 //===----------------------------------------------------------------------===//
 // LoadOp
 //===----------------------------------------------------------------------===//
 
 /// Returns true if the given type is supported by atomic operations. All
 /// integer and float types with limited bit width are supported. Additionally,
 /// depending on the operation pointers may be supported as well.
 static bool isTypeCompatibleWithAtomicOp(Type type, bool isPointerTypeAllowed) {
-  if (type.isa<LLVMPointerType>())
+  if (llvm::isa<LLVMPointerType>(type))
     return isPointerTypeAllowed;
 
   std::optional<unsigned> bitWidth;
-  if (auto floatType = type.dyn_cast<FloatType>()) {
+  if (auto floatType = llvm::dyn_cast<FloatType>(type)) {
     if (!isCompatibleFloatingPointType(type))
       return false;
     bitWidth = floatType.getWidth();
   }
-  if (auto integerType = type.dyn_cast<IntegerType>())
+  if (auto integerType = llvm::dyn_cast<IntegerType>(type))
     bitWidth = integerType.getWidth();
   // The type is neither an integer, float, or pointer type.
   if (!bitWidth)
     return false;
   return *bitWidth == 8 || *bitWidth == 16 || *bitWidth == 32 ||
          *bitWidth == 64;
 }
 

 LogicalResult LoadOp::verify() {
   Type valueType = getResult().getType();
   return verifyAtomicMemOp(*this, valueType,
                            {AtomicOrdering::release, AtomicOrdering::acq_rel});
 }
 
 void LoadOp::build(OpBuilder &builder, OperationState &state, Value addr,
                    unsigned alignment, bool isVolatile, bool isNonTemporal) {
-  auto type = addr.getType().cast<LLVMPointerType>().getElementType();
+  auto type = llvm::cast<LLVMPointerType>(addr.getType()).getElementType();
   assert(type && "must provide explicit element type to the constructor "
                  "when the pointer type is opaque");
   build(builder, state, type, addr, alignment, isVolatile, isNonTemporal);
 }
 
 void LoadOp::build(OpBuilder &builder, OperationState &state, Type type,
                    Value addr, unsigned alignment, bool isVolatile,
                    bool isNonTemporal, AtomicOrdering ordering,
                    StringRef syncscope) {
   build(builder, state, type, addr,
         alignment ? builder.getI64IntegerAttr(alignment) : nullptr, isVolatile,
         isNonTemporal, ordering,
         syncscope.empty() ? nullptr : builder.getStringAttr(syncscope),
         /*access_groups=*/nullptr,
         /*alias_scopes=*/nullptr, /*noalias_scopes=*/nullptr,
         /*tbaa=*/nullptr);
 }
 
 // Extract the pointee type from the LLVM pointer type wrapped in MLIR. Return
 // the resulting type if any, null type if opaque pointers are used, and
 // std::nullopt if the given type is not the pointer type.
 static std::optional<Type>
 getLoadStoreElementType(OpAsmParser &parser, Type type, SMLoc trailingTypeLoc) {
-  auto llvmTy = type.dyn_cast<LLVM::LLVMPointerType>();
+  auto llvmTy = llvm::dyn_cast<LLVM::LLVMPointerType>(type);
   if (!llvmTy) {
     parser.emitError(trailingTypeLoc, "expected LLVM pointer type");
     return std::nullopt;
   }
   return llvmTy.getElementType();
 }
 
 /// Parses the LoadOp type either using the typed or opaque pointer format.
void CallOp::build(OpBuilder &builder, OperationState &state, TypeRange results,
                    FlatSymbolRefAttr callee, ValueRange args) {
   build(builder, state, results, callee, args, nullptr, nullptr);
 }
 
 void CallOp::build(OpBuilder &builder, OperationState &state, LLVMFuncOp func,
                    ValueRange args) {
   SmallVector<Type> results;
   Type resultType = func.getFunctionType().getReturnType();
-  if (!resultType.isa<LLVM::LLVMVoidType>())
+  if (!llvm::isa<LLVM::LLVMVoidType>(resultType))
     results.push_back(resultType);
   build(builder, state, results, SymbolRefAttr::get(func), args, nullptr,
         nullptr);
 }
 
 CallInterfaceCallable CallOp::getCallableForCallee() {
   // Direct call.
   if (FlatSymbolRefAttr calleeAttr = getCalleeAttr())
LogicalResult CallOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
 
   // If this is an indirect call, the callee attribute is missing.
   FlatSymbolRefAttr calleeName = getCalleeAttr();
   if (!calleeName) {
     isIndirect = true;
     if (!getNumOperands())
       return emitOpError(
           "must have either a `callee` attribute or at least an operand");
-    auto ptrType = getOperand(0).getType().dyn_cast<LLVMPointerType>();
+    auto ptrType = llvm::dyn_cast<LLVMPointerType>(getOperand(0).getType());
     if (!ptrType)
       return emitOpError("indirect call expects a pointer as callee: ")
              << getOperand(0).getType();
 
     if (ptrType.isOpaque())
       return success();
 
     fnType = ptrType.getElementType();
   } else {
     Operation *callee =
         symbolTable.lookupNearestSymbolFrom(*this, calleeName.getAttr());
     if (!callee)
       return emitOpError()
              << "'" << calleeName.getValue()
              << "' does not reference a symbol in the current scope";
     auto fn = dyn_cast<LLVMFuncOp>(callee);
     if (!fn)
       return emitOpError() << "'" << calleeName.getValue()
                            << "' does not reference a valid LLVM function";
 
     fnType = fn.getFunctionType();
   }
 
-  LLVMFunctionType funcType = fnType.dyn_cast<LLVMFunctionType>();
+  LLVMFunctionType funcType = llvm::dyn_cast<LLVMFunctionType>(fnType);
   if (!funcType)
     return emitOpError("callee does not have a functional type: ") << fnType;
 
   // Indirect variadic function calls are not supported since the translation to
   // LLVM IR reconstructs the LLVM function type from the argument and result
   // types. An additional type attribute that stores the LLVM function type
   // would be needed to distinguish normal and variadic function arguments.
   // TODO: Support indirect calls to variadic function pointers.
LogicalResult CallOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
 
   for (unsigned i = 0, e = funcType.getNumParams(); i != e; ++i)
     if (getOperand(i + isIndirect).getType() != funcType.getParamType(i))
       return emitOpError() << "operand type mismatch for operand " << i << ": "
                            << getOperand(i + isIndirect).getType()
                            << " != " << funcType.getParamType(i);
 
   if (getNumResults() == 0 &&
-      !funcType.getReturnType().isa<LLVM::LLVMVoidType>())
+      !llvm::isa<LLVM::LLVMVoidType>(funcType.getReturnType()))
     return emitOpError() << "expected function call to produce a value";
 
   if (getNumResults() != 0 &&
-      funcType.getReturnType().isa<LLVM::LLVMVoidType>())
+      llvm::isa<LLVM::LLVMVoidType>(funcType.getReturnType()))
     return emitOpError()
            << "calling function with void result must not produce values";
 
   if (getNumResults() > 1)
     return emitOpError()
            << "expected LLVM function call to produce 0 or 1 result";
 
   if (getNumResults() && getResult().getType() != funcType.getReturnType())
static ParseResult parseCallTypeAndResolveOperands(
 
   if (isDirect && types.size() != 1)
     return parser.emitError(trailingTypesLoc,
                             "expected direct call to have 1 trailing type");
   if (!isDirect && types.size() != 2)
     return parser.emitError(trailingTypesLoc,
                             "expected indirect call to have 2 trailing types");
 
-  auto funcType = types.pop_back_val().dyn_cast<FunctionType>();
+  auto funcType = llvm::dyn_cast<FunctionType>(types.pop_back_val());
   if (!funcType)
     return parser.emitError(trailingTypesLoc,
                             "expected trailing function type");
   if (funcType.getNumResults() > 1)
     return parser.emitError(trailingTypesLoc,
                             "expected function with 0 or 1 result");
   if (funcType.getNumResults() == 1 &&
-      funcType.getResult(0).isa<LLVM::LLVMVoidType>())
+      llvm::isa<LLVM::LLVMVoidType>(funcType.getResult(0)))
     return parser.emitError(trailingTypesLoc,
                             "expected a non-void result type");
 
   // The head element of the types list matches the callee type for
   // indirect calls, while the types list is emtpy for direct calls.
   // Append the function input types to resolve the call operation
   // operands.
   llvm::append_range(types, funcType.getInputs());
LogicalResult LandingpadOp::verify() {
   // LLVMFuncOp::verify().
 
   if (!getCleanup() && getOperands().empty())
     return emitError("landingpad instruction expects at least one clause or "
                      "cleanup attribute");
 
   for (unsigned idx = 0, ie = getNumOperands(); idx < ie; idx++) {
     value = getOperand(idx);
-    bool isFilter = value.getType().isa<LLVMArrayType>();
+    bool isFilter = llvm::isa<LLVMArrayType>(value.getType());
     if (isFilter) {
       // FIXME: Verify filter clauses when arrays are appropriately handled
     } else {
       // catch - global addresses only.
       // Bitcast ops should have global addresses as their args.
       if (auto bcOp = value.getDefiningOp<BitcastOp>()) {
         if (auto addrOp = bcOp.getArg().getDefiningOp<AddressOfOp>())
           continue;

 
 void LandingpadOp::print(OpAsmPrinter &p) {
   p << (getCleanup() ? " cleanup " : " ");
 
   // Clauses
   for (auto value : getOperands()) {
     // Similar to llvm - if clause is an array type then it is filter
     // clause else catch clause
-    bool isArrayTy = value.getType().isa<LLVMArrayType>();
+    bool isArrayTy = llvm::isa<LLVMArrayType>(value.getType());
     p << '(' << (isArrayTy ? "filter " : "catch ") << value << " : "
       << value.getType() << ") ";
   }
 
   p.printOptionalAttrDict((*this)->getAttrs(), {"cleanup"});
 
   p << ": " << getType();
 }
if (!isCompatibleType(containerType)) {
     return {};
   }
 
   // Infer the element type from the structure type: iteratively step inside the
   // type by taking the element type, indexed by the position attribute for
   // structures.  Check the position index before accessing, it is supposed to
   // be in bounds.
   for (int64_t idx : position) {
-    if (auto arrayType = llvmType.dyn_cast<LLVMArrayType>()) {
+    if (auto arrayType = llvm::dyn_cast<LLVMArrayType>(llvmType)) {
       if (idx < 0 || static_cast<unsigned>(idx) >= arrayType.getNumElements()) {
         emitError("position out of bounds: ") << idx;
         return {};
       }
       llvmType = arrayType.getElementType();
-    } else if (auto structType = llvmType.dyn_cast<LLVMStructType>()) {
+    } else if (auto structType = llvm::dyn_cast<LLVMStructType>(llvmType)) {
       if (idx < 0 ||
           static_cast<unsigned>(idx) >= structType.getBody().size()) {
         emitError("position out of bounds: ") << idx;
         return {};
       }
       llvmType = structType.getBody()[idx];
     } else {
       emitError("expected LLVM IR structure/array type, got: ") << llvmType;
       return {};
     }
   }
   return llvmType;
 }
 
 /// Extract the type at `position` in the wrapped LLVM IR aggregate type
 /// `containerType`.
 static Type getInsertExtractValueElementType(Type llvmType,
                                              ArrayRef<int64_t> position) {
   for (int64_t idx : position) {
-    if (auto structType = llvmType.dyn_cast<LLVMStructType>())
+    if (auto structType = llvm::dyn_cast<LLVMStructType>(llvmType))
       llvmType = structType.getBody()[idx];
     else
-      llvmType = llvmType.cast<LLVMArrayType>().getElementType();
+      llvmType = llvm::cast<LLVMArrayType>(llvmType).getElementType();
   }
   return llvmType;
 }
 
 OpFoldResult LLVM::ExtractValueOp::fold(FoldAdaptor adaptor) {
   auto insertValueOp = getContainer().getDefiningOp<InsertValueOp>();
   OpFoldResult result = {};
   while (insertValueOp) {

 //===----------------------------------------------------------------------===//
 
 LogicalResult ReturnOp::verify() {
   auto parent = (*this)->getParentOfType<LLVMFuncOp>();
   if (!parent)
     return success();
 
   Type expectedType = parent.getFunctionType().getReturnType();
-  if (expectedType.isa<LLVMVoidType>()) {
+  if (llvm::isa<LLVMVoidType>(expectedType)) {
     if (!getArg())
       return success();
     InFlightDiagnostic diag = emitOpError("expected no operands");
     diag.attachNote(parent->getLoc()) << "when returning from function";
     return diag;
   }
   if (!getArg()) {
-    if (expectedType.isa<LLVMVoidType>())
+    if (llvm::isa<LLVMVoidType>(expectedType))
       return success();
     InFlightDiagnostic diag = emitOpError("expected 1 operand");
     diag.attachNote(parent->getLoc()) << "when returning from function";
     return diag;
   }
   if (expectedType != getArg().getType()) {
     InFlightDiagnostic diag = emitOpError("mismatching result types");
     diag.attachNote(parent->getLoc()) << "when returning from function";
void GlobalOp::print(OpAsmPrinter &p) {
   p.printOptionalAttrDict((*this)->getAttrs(),
                           {SymbolTable::getSymbolAttrName(),
                            getGlobalTypeAttrName(), getConstantAttrName(),
                            getValueAttrName(), getLinkageAttrName(),
                            getUnnamedAddrAttrName(), getThreadLocal_AttrName(),
                            getVisibility_AttrName()});
 
   // Print the trailing type unless it's a string global.
-  if (getValueOrNull().dyn_cast_or_null<StringAttr>())
+  if (llvm::dyn_cast_or_null<StringAttr>(getValueOrNull()))
     return;
   p << " : " << getType();
 
   Region &initializer = getInitializerRegion();
   if (!initializer.empty()) {
     p << ' ';
     p.printRegion(initializer, /*printEntryBlockArgs=*/false);
   }
if (parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseOptionalColonTypeList(types))
     return failure();
 
   if (types.size() > 1)
     return parser.emitError(parser.getNameLoc(), "expected zero or one type");
 
   Region &initRegion = *result.addRegion();
   if (types.empty()) {
-    if (auto strAttr = value.dyn_cast_or_null<StringAttr>()) {
+    if (auto strAttr = llvm::dyn_cast_or_null<StringAttr>(value)) {
       MLIRContext *context = parser.getContext();
       auto arrayType = LLVM::LLVMArrayType::get(IntegerType::get(context, 8),
                                                 strAttr.getValue().size());
       types.push_back(arrayType);
     } else {
       return parser.emitError(parser.getNameLoc(),
                               "type can only be omitted for string globals");
     }
   } else {
     OptionalParseResult parseResult =
         parser.parseOptionalRegion(initRegion, /*arguments=*/{},
                                    /*argTypes=*/{});
     if (parseResult.has_value() && failed(*parseResult))
       return failure();
   }
 
   result.addAttribute(getGlobalTypeAttrName(result.name),
                       TypeAttr::get(types[0]));
   return success();
 }
 
 static bool isZeroAttribute(Attribute value) {
-  if (auto intValue = value.dyn_cast<IntegerAttr>())
+  if (auto intValue = llvm::dyn_cast<IntegerAttr>(value))
     return intValue.getValue().isZero();
-  if (auto fpValue = value.dyn_cast<FloatAttr>())
+  if (auto fpValue = llvm::dyn_cast<FloatAttr>(value))
     return fpValue.getValue().isZero();
-  if (auto splatValue = value.dyn_cast<SplatElementsAttr>())
+  if (auto splatValue = llvm::dyn_cast<SplatElementsAttr>(value))
     return isZeroAttribute(splatValue.getSplatValue<Attribute>());
-  if (auto elementsValue = value.dyn_cast<ElementsAttr>())
+  if (auto elementsValue = llvm::dyn_cast<ElementsAttr>(value))
     return llvm::all_of(elementsValue.getValues<Attribute>(), isZeroAttribute);
-  if (auto arrayValue = value.dyn_cast<ArrayAttr>())
+  if (auto arrayValue = llvm::dyn_cast<ArrayAttr>(value))
     return llvm::all_of(arrayValue.getValue(), isZeroAttribute);
   return false;
 }
 
 LogicalResult GlobalOp::verify() {
   if (!LLVMPointerType::isValidElementType(getType()))
     return emitOpError(
         "expects type to be a valid element type for an LLVM pointer");
   if ((*this)->getParentOp() && !satisfiesLLVMModule((*this)->getParentOp()))
     return emitOpError("must appear at the module level");
 
-  if (auto strAttr = getValueOrNull().dyn_cast_or_null<StringAttr>()) {
-    auto type = getType().dyn_cast<LLVMArrayType>();
+  if (auto strAttr = llvm::dyn_cast_or_null<StringAttr>(getValueOrNull())) {
+    auto type = llvm::dyn_cast<LLVMArrayType>(getType());
     IntegerType elementType =
-        type ? type.getElementType().dyn_cast<IntegerType>() : nullptr;
+        type ? llvm::dyn_cast<IntegerType>(type.getElementType()) : nullptr;
     if (!elementType || elementType.getWidth() != 8 ||
         type.getNumElements() != strAttr.getValue().size())
       return emitOpError(
           "requires an i8 array type of the length equal to that of the string "
           "attribute");
   }
 
   if (getLinkage() == Linkage::Common) {
     if (Attribute value = getValueOrNull()) {
       if (!isZeroAttribute(value)) {
         return emitOpError()
                << "expected zero value for '"
                << stringifyLinkage(Linkage::Common) << "' linkage";
       }
     }
   }
 
   if (getLinkage() == Linkage::Appending) {
-    if (!getType().isa<LLVMArrayType>()) {
+    if (!llvm::isa<LLVMArrayType>(getType())) {
       return emitOpError() << "expected array type for '"
                            << stringifyLinkage(Linkage::Appending)
                            << "' linkage";
     }
   }
 
   std::optional<uint64_t> alignAttr = getAlignment();
   if (alignAttr.has_value()) {

 
 //===----------------------------------------------------------------------===//
 // LLVM::GlobalCtorsOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 GlobalCtorsOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
   for (Attribute ctor : getCtors()) {
-    if (failed(verifySymbolAttrUse(ctor.cast<FlatSymbolRefAttr>(), *this,
+    if (failed(verifySymbolAttrUse(llvm::cast<FlatSymbolRefAttr>(ctor), *this,
                                    symbolTable)))
       return failure();
   }
   return success();
 }
 
 LogicalResult GlobalCtorsOp::verify() {
   if (getCtors().size() != getPriorities().size())
     return emitError(
         "mismatch between the number of ctors and the number of priorities");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // LLVM::GlobalDtorsOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 GlobalDtorsOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
   for (Attribute dtor : getDtors()) {
-    if (failed(verifySymbolAttrUse(dtor.cast<FlatSymbolRefAttr>(), *this,
+    if (failed(verifySymbolAttrUse(llvm::cast<FlatSymbolRefAttr>(dtor), *this,
                                    symbolTable)))
       return failure();
   }
   return success();
 }
 
 LogicalResult GlobalDtorsOp::verify() {
   if (getDtors().size() != getPriorities().size())
if (dsoLocal)
     result.addAttribute(getDsoLocalAttrName(result.name),
                         builder.getUnitAttr());
   if (functionEntryCount)
     result.addAttribute(getFunctionEntryCountAttrName(result.name),
                         builder.getI64IntegerAttr(functionEntryCount.value()));
   if (argAttrs.empty())
     return;
 
-  assert(type.cast<LLVMFunctionType>().getNumParams() == argAttrs.size() &&
+  assert(llvm::cast<LLVMFunctionType>(type).getNumParams() == argAttrs.size() &&
          "expected as many argument attribute lists as arguments");
   function_interface_impl::addArgAndResultAttrs(
       builder, result, argAttrs, /*resultAttrs=*/std::nullopt,
       getArgAttrsAttrName(result.name), getResAttrsAttrName(result.name));
 }
 
 // Builds an LLVM function type from the given lists of input and output types.
 // Returns a null type if any of the types provided are non-LLVM types, or if
void LLVMFuncOp::print(OpAsmPrinter &p) {
   LLVMFunctionType fnType = getFunctionType();
   SmallVector<Type, 8> argTypes;
   SmallVector<Type, 1> resTypes;
   argTypes.reserve(fnType.getNumParams());
   for (unsigned i = 0, e = fnType.getNumParams(); i < e; ++i)
     argTypes.push_back(fnType.getParamType(i));
 
   Type returnType = fnType.getReturnType();
-  if (!returnType.isa<LLVMVoidType>())
+  if (!llvm::isa<LLVMVoidType>(returnType))
     resTypes.push_back(returnType);
 
   function_interface_impl::printFunctionSignature(p, *this, argTypes,
                                                   isVarArg(), resTypes);
   function_interface_impl::printFunctionAttributes(
       p, *this,
       {getFunctionTypeAttrName(), getArgAttrsAttrName(), getResAttrsAttrName(),
        getLinkageAttrName(), getCConvAttrName(), getVisibility_AttrName()});
Region *LLVMFuncOp::getCallableRegion() {
   return &getBody();
 }
 
 //===----------------------------------------------------------------------===//
 // Verification for LLVM::ConstantOp.
 //===----------------------------------------------------------------------===//
 
 LogicalResult LLVM::ConstantOp::verify() {
-  if (StringAttr sAttr = getValue().dyn_cast<StringAttr>()) {
-    auto arrayType = getType().dyn_cast<LLVMArrayType>();
+  if (StringAttr sAttr = llvm::dyn_cast<StringAttr>(getValue())) {
+    auto arrayType = llvm::dyn_cast<LLVMArrayType>(getType());
     if (!arrayType || arrayType.getNumElements() != sAttr.getValue().size() ||
         !arrayType.getElementType().isInteger(8)) {
       return emitOpError() << "expected array type of "
                            << sAttr.getValue().size()
                            << " i8 elements for the string constant";
     }
     return success();
   }
-  if (auto structType = getType().dyn_cast<LLVMStructType>()) {
+  if (auto structType = llvm::dyn_cast<LLVMStructType>(getType())) {
     if (structType.getBody().size() != 2 ||
         structType.getBody()[0] != structType.getBody()[1]) {
       return emitError() << "expected struct type with two elements of the "
                             "same type, the type of a complex constant";
     }
 
-    auto arrayAttr = getValue().dyn_cast<ArrayAttr>();
+    auto arrayAttr = llvm::dyn_cast<ArrayAttr>(getValue());
     if (!arrayAttr || arrayAttr.size() != 2) {
       return emitOpError() << "expected array attribute with two elements, "
                               "representing a complex constant";
     }
-    auto re = arrayAttr[0].dyn_cast<TypedAttr>();
-    auto im = arrayAttr[1].dyn_cast<TypedAttr>();
+    auto re = llvm::dyn_cast<TypedAttr>(arrayAttr[0]);
+    auto im = llvm::dyn_cast<TypedAttr>(arrayAttr[1]);
     if (!re || !im || re.getType() != im.getType()) {
       return emitOpError()
              << "expected array attribute with two elements of the same type";
     }
 
     Type elementType = structType.getBody()[0];
-    if (!elementType
-             .isa<IntegerType, Float16Type, Float32Type, Float64Type>()) {
+    if (!llvm::isa<IntegerType, Float16Type, Float32Type, Float64Type>(
+            elementType)) {
       return emitError()
              << "expected struct element types to be floating point type or "
                 "integer type";
     }
     return success();
   }
-  if (!getValue().isa<IntegerAttr, ArrayAttr, FloatAttr, ElementsAttr>())
+  if (!llvm::isa<IntegerAttr, ArrayAttr, FloatAttr, ElementsAttr>(getValue()))
     return emitOpError()
            << "only supports integer, float, string or elements attributes";
   return success();
 }
 
 // Constant op constant-folds to its value.
 OpFoldResult LLVM::ConstantOp::fold(FoldAdaptor) { return getValue(); }
 
 //===----------------------------------------------------------------------===//
 // AtomicRMWOp
 //===----------------------------------------------------------------------===//
 
 void AtomicRMWOp::build(OpBuilder &builder, OperationState &state,
                         AtomicBinOp binOp, Value ptr, Value val,
                         AtomicOrdering ordering, StringRef syncscope,
                         unsigned alignment, bool isVolatile) {
   build(builder, state, val.getType(), binOp, ptr, val, ordering,
         !syncscope.empty() ? builder.getStringAttr(syncscope) : nullptr,
         alignment ? builder.getI64IntegerAttr(alignment) : nullptr, isVolatile,
         /*access_groups=*/nullptr,
         /*alias_scopes=*/nullptr, /*noalias_scopes=*/nullptr, /*tbaa=*/nullptr);
 }
 
 LogicalResult AtomicRMWOp::verify() {
-  auto ptrType = getPtr().getType().cast<LLVM::LLVMPointerType>();
+  auto ptrType = llvm::cast<LLVM::LLVMPointerType>(getPtr().getType());
   auto valType = getVal().getType();
   if (!ptrType.isOpaque() && valType != ptrType.getElementType())
     return emitOpError("expected LLVM IR element type for operand #0 to "
                        "match type for operand #1");
   if (getBinOp() == AtomicBinOp::fadd || getBinOp() == AtomicBinOp::fsub ||
       getBinOp() == AtomicBinOp::fmin || getBinOp() == AtomicBinOp::fmax) {
     if (!mlir::LLVM::isCompatibleFloatingPointType(valType))
       return emitOpError("expected LLVM IR floating point type");
   } else if (getBinOp() == AtomicBinOp::xchg) {
     if (!isTypeCompatibleWithAtomicOp(valType, /*isPointerTypeAllowed=*/false))
       return emitOpError("unexpected LLVM IR type for 'xchg' bin_op");
   } else {
-    auto intType = valType.dyn_cast<IntegerType>();
+    auto intType = llvm::dyn_cast<IntegerType>(valType);
     unsigned intBitWidth = intType ? intType.getWidth() : 0;
     if (intBitWidth != 8 && intBitWidth != 16 && intBitWidth != 32 &&
         intBitWidth != 64)
       return emitOpError("expected LLVM IR integer type");
   }
 
   if (static_cast<unsigned>(getOrdering()) <
       static_cast<unsigned>(AtomicOrdering::monotonic))
build(builder, state, getValAndBoolStructType(val.getType()), ptr, cmp, val,
         successOrdering, failureOrdering,
         !syncscope.empty() ? builder.getStringAttr(syncscope) : nullptr,
         alignment ? builder.getI64IntegerAttr(alignment) : nullptr, isWeak,
         isVolatile, /*access_groups=*/nullptr,
         /*alias_scopes=*/nullptr, /*noalias_scopes=*/nullptr, /*tbaa=*/nullptr);
 }
 
 LogicalResult AtomicCmpXchgOp::verify() {
-  auto ptrType = getPtr().getType().cast<LLVM::LLVMPointerType>();
+  auto ptrType = llvm::cast<LLVM::LLVMPointerType>(getPtr().getType());
   if (!ptrType)
     return emitOpError("expected LLVM IR pointer type for operand #0");
   auto valType = getVal().getType();
   if (!ptrType.isOpaque() && valType != ptrType.getElementType())
     return emitOpError("expected LLVM IR element type for operand #0 to "
                        "match type for all other operands");
   if (!isTypeCompatibleWithAtomicOp(valType,
                                     /*isPointerTypeAllowed=*/true))
OpFoldResult LLVM::BitcastOp::fold(FoldAdaptor adaptor) {
   // bitcast(bitcast(x : T0, T1), T0) -> x
   if (auto prev = getArg().getDefiningOp<BitcastOp>())
     if (prev.getArg().getType() == getType())
       return prev.getArg();
   return {};
 }
 
 LogicalResult LLVM::BitcastOp::verify() {
-  auto resultType = extractVectorElementType(getResult().getType())
-                        .dyn_cast<LLVMPointerType>();
-  auto sourceType =
-      extractVectorElementType(getArg().getType()).dyn_cast<LLVMPointerType>();
+  auto resultType = llvm::dyn_cast<LLVMPointerType>(
+      extractVectorElementType(getResult().getType()));
+  auto sourceType = llvm::dyn_cast<LLVMPointerType>(
+      extractVectorElementType(getArg().getType()));
 
   // If one of the types is a pointer (or vector of pointers), then
   // both source and result type have to be pointers.
   if (static_cast<bool>(resultType) != static_cast<bool>(sourceType))
     return emitOpError("can only cast pointers from and to pointers");
 
   if (!resultType)
     return success();
 
   auto isVector = [](Type type) {
-    return type.isa<VectorType, LLVMScalableVectorType, LLVMFixedVectorType>();
+    return llvm::isa<VectorType, LLVMScalableVectorType, LLVMFixedVectorType>(
+        type);
   };
 
   // Due to bitcast requiring both operands to be of the same size, it is not
   // possible for only one of the two to be a pointer of vectors.
   if (isVector(getResult().getType()) && !isVector(getArg().getType()))
     return emitOpError("cannot cast pointer to vector of pointers");
 
   if (!isVector(getResult().getType()) && isVector(getArg().getType()))

 //===----------------------------------------------------------------------===//
 
 OpFoldResult LLVM::GEPOp::fold(FoldAdaptor adaptor) {
   GEPIndicesAdaptor<ArrayRef<Attribute>> indices(getRawConstantIndicesAttr(),
                                                  adaptor.getDynamicIndices());
 
   // gep %x:T, 0 -> %x
   if (getBase().getType() == getType() && indices.size() == 1)
-    if (auto integer = indices[0].dyn_cast_or_null<IntegerAttr>())
+    if (auto integer = llvm::dyn_cast_or_null<IntegerAttr>(indices[0]))
       if (integer.getValue().isZero())
         return getBase();
 
   // Canonicalize any dynamic indices of constant value to constant indices.
   bool changed = false;
   SmallVector<GEPArg> gepArgs;
   for (auto iter : llvm::enumerate(indices)) {
-    auto integer = iter.value().dyn_cast_or_null<IntegerAttr>();
+    auto integer = llvm::dyn_cast_or_null<IntegerAttr>(iter.value());
     // Constant indices can only be int32_t, so if integer does not fit we
     // are forced to keep it dynamic, despite being a constant.
     if (!indices.isDynamicIndex(iter.index()) || !integer ||
         !integer.getValue().isSignedIntN(kGEPConstantBitWidth)) {
 
       PointerUnion<IntegerAttr, Value> existing = getIndices()[iter.index()];
       if (Value val = existing.dyn_cast<Value>())
         gepArgs.emplace_back(val);
return op.emitOpError()
            << LLVM::TBAATypeDescriptorOp::getOperationName()
            << "' while it references '@" << symbolName.getValue() << "'";
   };
   for (Operation &op : body.getOps()) {
     if (auto tdOp = dyn_cast<LLVM::TBAATypeDescriptorOp>(op)) {
       SmallVectorImpl<TBAAGraphNode *> &operands =
           tbaaGraph[tdOp.getSymNameAttr()]->operands;
       for (Attribute attr : tdOp.getMembers()) {
-        StringAttr symbolRef = attr.cast<FlatSymbolRefAttr>().getAttr();
+        StringAttr symbolRef = llvm::cast<FlatSymbolRefAttr>(attr).getAttr();
         if (failed(verifyReference(op, symbolRef, tdOp.getMembersAttrName())))
           return failure();
 
         // Since the reference is valid, we have to be able
         // to find TBAAGraphNode corresponding to the operand.
         operands.push_back(tbaaGraph[symbolRef]);
       }
     }

 LogicalResult LLVMDialect::verifyOperationAttribute(Operation *op,
                                                     NamedAttribute attr) {
   // If the data layout attribute is present, it must use the LLVM data layout
   // syntax. Try parsing it and report errors in case of failure. Users of this
   // attribute may assume it is well-formed and can pass it to the (asserting)
   // llvm::DataLayout constructor.
   if (attr.getName() != LLVM::LLVMDialect::getDataLayoutAttrName())
     return success();
-  if (auto stringAttr = attr.getValue().dyn_cast<StringAttr>())
+  if (auto stringAttr = llvm::dyn_cast<StringAttr>(attr.getValue()))
     return verifyDataLayoutString(
         stringAttr.getValue(),
         [op](const Twine &message) { op->emitOpError() << message.str(); });
 
   return op->emitOpError() << "expected '"
                            << LLVM::LLVMDialect::getDataLayoutAttrName()
                            << "' to be a string attributes";
 }
 
 LogicalResult LLVMDialect::verifyParameterAttribute(Operation *op,
                                                     Type paramType,
                                                     NamedAttribute paramAttr) {
   // LLVM attribute may be attached to a result of operation that has not been
   // converted to LLVM dialect yet, so the result may have a type with unknown
   // representation in LLVM dialect type space. In this case we cannot verify
   // whether the attribute may be
   bool verifyValueType = isCompatibleType(paramType);
   StringAttr name = paramAttr.getName();
 
   auto checkUnitAttrType = [&]() -> LogicalResult {
-    if (!paramAttr.getValue().isa<UnitAttr>())
+    if (!llvm::isa<UnitAttr>(paramAttr.getValue()))
       return op->emitError() << name << " should be a unit attribute";
     return success();
   };
   auto checkTypeAttrType = [&]() -> LogicalResult {
-    if (!paramAttr.getValue().isa<TypeAttr>())
+    if (!llvm::isa<TypeAttr>(paramAttr.getValue()))
       return op->emitError() << name << " should be a type attribute";
     return success();
   };
   auto checkIntegerAttrType = [&]() -> LogicalResult {
-    if (!paramAttr.getValue().isa<IntegerAttr>())
+    if (!llvm::isa<IntegerAttr>(paramAttr.getValue()))
       return op->emitError() << name << " should be an integer attribute";
     return success();
   };
   auto checkPointerType = [&]() -> LogicalResult {
-    if (!paramType.isa<LLVMPointerType>())
+    if (!llvm::isa<LLVMPointerType>(paramType))
       return op->emitError()
              << name << " attribute attached to non-pointer LLVM type";
     return success();
   };
   auto checkIntegerType = [&]() -> LogicalResult {
-    if (!paramType.isa<IntegerType>())
+    if (!llvm::isa<IntegerType>(paramType))
       return op->emitError()
              << name << " attribute attached to non-integer LLVM type";
     return success();
   };
   auto checkPointerTypeMatches = [&]() -> LogicalResult {
     if (failed(checkPointerType()))
       return failure();
-    auto ptrType = paramType.cast<LLVMPointerType>();
-    auto typeAttr = paramAttr.getValue().cast<TypeAttr>();
+    auto ptrType = llvm::cast<LLVMPointerType>(paramType);
+    auto typeAttr = llvm::cast<TypeAttr>(paramAttr.getValue());
 
     if (!ptrType.isOpaque() && ptrType.getElementType() != typeAttr.getValue())
       return op->emitError()
              << name
              << " attribute attached to LLVM pointer argument of "
                 "different type";
     return success();
   };
LogicalResult LLVMDialect::verifyRegionResultAttribute(Operation *op,
                                                        NamedAttribute resAttr) {
   auto funcOp = dyn_cast<FunctionOpInterface>(op);
   if (!funcOp)
     return success();
   Type resType = funcOp.getResultTypes()[resIdx];
 
   // Check to see if this function has a void return with a result attribute
   // to it. It isn't clear what semantics we would assign to that.
-  if (resType.isa<LLVMVoidType>())
+  if (llvm::isa<LLVMVoidType>(resType))
     return op->emitError() << "cannot attach result attributes to functions "
                               "with a void return";
 
   // Check to see if this attribute is allowed as a result attribute. Only
   // explicitly forbidden LLVM attributes will cause an error.
   auto name = resAttr.getName();
   if (name == LLVMDialect::getAllocAlignAttrName() ||
       name == LLVMDialect::getAllocatedPointerAttrName() ||

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

if (Operation *definingOp = value.getDefiningOp()) {
     return 1;
   }
   // Since there is no defining op, this is a block argument. Probably this
   // comes directly from a function argument, so check that this is the case.
   Operation *parentOp = value.getParentBlock()->getParentOp();
   if (auto func = dyn_cast<LLVM::LLVMFuncOp>(parentOp)) {
     // Use the alignment attribute set for this argument in the parent function
     // if it has been set.
-    auto blockArg = value.cast<BlockArgument>();
+    auto blockArg = llvm::cast<BlockArgument>(value);
     if (Attribute alignAttr = func.getArgAttr(
             blockArg.getArgNumber(), LLVM::LLVMDialect::getAlignAttrName()))
       return cast<IntegerAttr>(alignAttr).getValue().getLimitedValue();
   }
   // We didn't find anything useful; assume no alignment.
   return 1;
 }
 

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

verifySymbolRefs(Operation *op, StringRef name, ArrayAttr symbolRefs,
                      verifySymbolType) {
   assert(symbolRefs && "expected a non-null attribute");
 
   // Verify that the attribute is a symbol ref array attribute,
   // because this constraint is not verified for all attribute
   // names processed here (e.g. 'tbaa'). This verification
   // is redundant in some cases.
   if (!llvm::all_of(symbolRefs, [](Attribute attr) {
-        return attr && attr.isa<SymbolRefAttr>();
+        return attr && llvm::isa<SymbolRefAttr>(attr);
       }))
     return op->emitOpError() << name
                              << " attribute failed to satisfy constraint: "
                                 "symbol ref array attribute";
 
   for (SymbolRefAttr symbolRef : symbolRefs.getAsRange<SymbolRefAttr>()) {
     StringAttr metadataName = symbolRef.getRootReference();
     StringAttr symbolName = symbolRef.getLeafReference();

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

 //===----------------------------------------------------------------------===//
 // Printing.
 //===----------------------------------------------------------------------===//
 
 /// If the given type is compatible with the LLVM dialect, prints it using
 /// internal functions to avoid getting a verbose `!llvm` prefix. Otherwise
 /// prints it as usual.
 static void dispatchPrint(AsmPrinter &printer, Type type) {
-  if (isCompatibleType(type) && !type.isa<IntegerType, FloatType, VectorType>())
+  if (isCompatibleType(type) &&
+      !llvm::isa<IntegerType, FloatType, VectorType>(type))
     return mlir::LLVM::detail::printType(type, printer);
   printer.printType(type);
 }
 
 /// Returns the keyword to use for the given type.
 static StringRef getTypeKeyword(Type type) {
   return TypeSwitch<Type, StringRef>(type)
       .Case<LLVMVoidType>([&](Type) { return "void"; })

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

 #define GET_TYPEDEF_CLASSES
 #include "mlir/Dialect/LLVMIR/LLVMTypes.cpp.inc"
 
 //===----------------------------------------------------------------------===//
 // LLVMArrayType
 //===----------------------------------------------------------------------===//
 
 bool LLVMArrayType::isValidElementType(Type type) {
-  return !type.isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
-                   LLVMFunctionType, LLVMTokenType, LLVMScalableVectorType>();
+  return !llvm::isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
+                    LLVMFunctionType, LLVMTokenType, LLVMScalableVectorType>(
+      type);
 }
 
 LLVMArrayType LLVMArrayType::get(Type elementType, unsigned numElements) {
   assert(elementType && "expected non-null subtype");
   return Base::get(elementType.getContext(), elementType, numElements);
 }
 
 LLVMArrayType
LLVMArrayType::getPreferredAlignment(const DataLayout &dataLayout,
   return dataLayout.getTypePreferredAlignment(getElementType());
 }
 
 //===----------------------------------------------------------------------===//
 // Function type.
 //===----------------------------------------------------------------------===//
 
 bool LLVMFunctionType::isValidArgumentType(Type type) {
-  return !type.isa<LLVMVoidType, LLVMFunctionType>();
+  return !llvm::isa<LLVMVoidType, LLVMFunctionType>(type);
 }
 
 bool LLVMFunctionType::isValidResultType(Type type) {
-  return !type.isa<LLVMFunctionType, LLVMMetadataType, LLVMLabelType>();
+  return !llvm::isa<LLVMFunctionType, LLVMMetadataType, LLVMLabelType>(type);
 }
 
 LLVMFunctionType LLVMFunctionType::get(Type result, ArrayRef<Type> arguments,
                                        bool isVarArg) {
   assert(result && "expected non-null result");
   return Base::get(result.getContext(), result, arguments, isVarArg);
 }
 

 //===----------------------------------------------------------------------===//
 // LLVMPointerType
 //===----------------------------------------------------------------------===//
 
 bool LLVMPointerType::isValidElementType(Type type) {
   if (!type)
     return true;
   return isCompatibleOuterType(type)
-             ? !type.isa<LLVMVoidType, LLVMTokenType, LLVMMetadataType,
-                         LLVMLabelType>()
-             : type.isa<PointerElementTypeInterface>();
+             ? !llvm::isa<LLVMVoidType, LLVMTokenType, LLVMMetadataType,
+                          LLVMLabelType>(type)
+             : llvm::isa<PointerElementTypeInterface>(type);
 }
 
 LLVMPointerType LLVMPointerType::get(Type pointee, unsigned addressSpace) {
   assert(pointee && "expected non-null subtype, pass the context instead if "
                     "the opaque pointer type is desired");
   return Base::get(pointee.getContext(), pointee, addressSpace);
 }
 
 LogicalResult
 LLVMPointerType::verify(function_ref<InFlightDiagnostic()> emitError,
                         Type pointee, unsigned) {
   if (!isValidElementType(pointee))
     return emitError() << "invalid pointer element type: " << pointee;
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // DataLayoutTypeInterface
 
 constexpr const static unsigned kDefaultPointerSizeBits = 64;
 constexpr const static unsigned kDefaultPointerAlignment = 8;
 
 std::optional<unsigned> mlir::LLVM::extractPointerSpecValue(Attribute attr,
                                                             PtrDLEntryPos pos) {
-  auto spec = attr.cast<DenseIntElementsAttr>();
+  auto spec = llvm::cast<DenseIntElementsAttr>(attr);
   auto idx = static_cast<unsigned>(pos);
   if (idx >= spec.size())
     return std::nullopt;
   return spec.getValues<unsigned>()[idx];
 }
 
 /// Returns the part of the data layout entry that corresponds to `pos` for the
 /// given `type` by interpreting the list of entries `params`. For the pointer
 /// type in the default address space, returns the default value if the entries
 /// do not provide a custom one, for other address spaces returns std::nullopt.
 static std::optional<unsigned>
 getPointerDataLayoutEntry(DataLayoutEntryListRef params, LLVMPointerType type,
                           PtrDLEntryPos pos) {
   // First, look for the entry for the pointer in the current address space.
   Attribute currentEntry;
   for (DataLayoutEntryInterface entry : params) {
     if (!entry.isTypeEntry())
       continue;
-    if (entry.getKey().get<Type>().cast<LLVMPointerType>().getAddressSpace() ==
-        type.getAddressSpace()) {
+    if (llvm::cast<LLVMPointerType>(entry.getKey().get<Type>())
+            .getAddressSpace() == type.getAddressSpace()) {
       currentEntry = entry.getValue();
       break;
     }
   }
   if (currentEntry) {
     return *extractPointerSpecValue(currentEntry, pos) /
            (pos == PtrDLEntryPos::Size ? 1 : kBitsInByte);
   }

 
 bool LLVMPointerType::areCompatible(DataLayoutEntryListRef oldLayout,
                                     DataLayoutEntryListRef newLayout) const {
   for (DataLayoutEntryInterface newEntry : newLayout) {
     if (!newEntry.isTypeEntry())
       continue;
     unsigned size = kDefaultPointerSizeBits;
     unsigned abi = kDefaultPointerAlignment;
-    auto newType = newEntry.getKey().get<Type>().cast<LLVMPointerType>();
+    auto newType = llvm::cast<LLVMPointerType>(newEntry.getKey().get<Type>());
     const auto *it =
         llvm::find_if(oldLayout, [&](DataLayoutEntryInterface entry) {
           if (auto type = entry.getKey().dyn_cast<Type>()) {
-            return type.cast<LLVMPointerType>().getAddressSpace() ==
+            return llvm::cast<LLVMPointerType>(type).getAddressSpace() ==
                    newType.getAddressSpace();
           }
           return false;
         });
     if (it == oldLayout.end()) {
       llvm::find_if(oldLayout, [&](DataLayoutEntryInterface entry) {
         if (auto type = entry.getKey().dyn_cast<Type>()) {
-          return type.cast<LLVMPointerType>().getAddressSpace() == 0;
+          return llvm::cast<LLVMPointerType>(type).getAddressSpace() == 0;
         }
         return false;
       });
     }
     if (it != oldLayout.end()) {
       size = *extractPointerSpecValue(*it, PtrDLEntryPos::Size);
       abi = *extractPointerSpecValue(*it, PtrDLEntryPos::Abi);
     }
 
-    Attribute newSpec = newEntry.getValue().cast<DenseIntElementsAttr>();
+    Attribute newSpec = llvm::cast<DenseIntElementsAttr>(newEntry.getValue());
     unsigned newSize = *extractPointerSpecValue(newSpec, PtrDLEntryPos::Size);
     unsigned newAbi = *extractPointerSpecValue(newSpec, PtrDLEntryPos::Abi);
     if (size != newSize || abi < newAbi || abi % newAbi != 0)
       return false;
   }
   return true;
 }
 
 LogicalResult LLVMPointerType::verifyEntries(DataLayoutEntryListRef entries,
                                              Location loc) const {
   for (DataLayoutEntryInterface entry : entries) {
     if (!entry.isTypeEntry())
       continue;
-    auto key = entry.getKey().get<Type>().cast<LLVMPointerType>();
-    auto values = entry.getValue().dyn_cast<DenseIntElementsAttr>();
+    auto key = llvm::cast<LLVMPointerType>(entry.getKey().get<Type>());
+    auto values = llvm::dyn_cast<DenseIntElementsAttr>(entry.getValue());
     if (!values || (values.size() != 3 && values.size() != 4)) {
       return emitError(loc)
              << "expected layout attribute for " << entry.getKey().get<Type>()
              << " to be a dense integer elements attribute with 3 or 4 "
                 "elements";
     }
     if (key.getElementType() && !key.getElementType().isInteger(8)) {
       return emitError(loc) << "unexpected layout attribute for pointer to "
                             << key.getElementType();
     }
     if (extractPointerSpecValue(values, PtrDLEntryPos::Abi) >
         extractPointerSpecValue(values, PtrDLEntryPos::Preferred)) {
       return emitError(loc) << "preferred alignment is expected to be at least "
                                "as large as ABI alignment";
     }
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Struct type.
 //===----------------------------------------------------------------------===//
 
 bool LLVMStructType::isValidElementType(Type type) {
-  return !type.isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
-                   LLVMFunctionType, LLVMTokenType, LLVMScalableVectorType>();
+  return !llvm::isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
+                    LLVMFunctionType, LLVMTokenType, LLVMScalableVectorType>(
+      type);
 }
 
 LLVMStructType LLVMStructType::getIdentified(MLIRContext *context,
                                              StringRef name) {
   return Base::get(context, name, /*opaque=*/false);
 }
 
 LLVMStructType LLVMStructType::getIdentifiedChecked(
getStructDataLayoutEntry(DataLayoutEntryListRef params, LLVMStructType type,
                          StructDLEntryPos pos) {
   const auto *currentEntry =
       llvm::find_if(params, [](DataLayoutEntryInterface entry) {
         return entry.isTypeEntry();
       });
   if (currentEntry == params.end())
     return std::nullopt;
 
-  auto attr = currentEntry->getValue().cast<DenseIntElementsAttr>();
+  auto attr = llvm::cast<DenseIntElementsAttr>(currentEntry->getValue());
   if (pos == StructDLEntryPos::Preferred &&
       attr.size() <= static_cast<unsigned>(StructDLEntryPos::Preferred))
     // If no preferred was specified, fall back to abi alignment
     pos = StructDLEntryPos::Abi;
 
   return attr.getValues<unsigned>()[static_cast<unsigned>(pos)];
 }
 

 unsigned
 LLVMStructType::getPreferredAlignment(const DataLayout &dataLayout,
                                       DataLayoutEntryListRef params) const {
   return calculateStructAlignment(dataLayout, params, *this,
                                   StructDLEntryPos::Preferred);
 }
 
 static unsigned extractStructSpecValue(Attribute attr, StructDLEntryPos pos) {
-  return attr.cast<DenseIntElementsAttr>()
+  return llvm::cast<DenseIntElementsAttr>(attr)
       .getValues<unsigned>()[static_cast<unsigned>(pos)];
 }
 
 bool LLVMStructType::areCompatible(DataLayoutEntryListRef oldLayout,
                                    DataLayoutEntryListRef newLayout) const {
   for (DataLayoutEntryInterface newEntry : newLayout) {
     if (!newEntry.isTypeEntry())
       continue;

 }
 
 LogicalResult LLVMStructType::verifyEntries(DataLayoutEntryListRef entries,
                                             Location loc) const {
   for (DataLayoutEntryInterface entry : entries) {
     if (!entry.isTypeEntry())
       continue;
 
-    auto key = entry.getKey().get<Type>().cast<LLVMStructType>();
-    auto values = entry.getValue().dyn_cast<DenseIntElementsAttr>();
+    auto key = llvm::cast<LLVMStructType>(entry.getKey().get<Type>());
+    auto values = llvm::dyn_cast<DenseIntElementsAttr>(entry.getValue());
     if (!values || (values.size() != 2 && values.size() != 1)) {
       return emitError(loc)
              << "expected layout attribute for " << entry.getKey().get<Type>()
              << " to be a dense integer elements attribute of 1 or 2 elements";
     }
 
     if (key.isIdentified() || !key.getBody().empty()) {
       return emitError(loc) << "unexpected layout attribute for struct " << key;

 LLVMFixedVectorType::getChecked(function_ref<InFlightDiagnostic()> emitError,
                                 Type elementType, unsigned numElements) {
   assert(elementType && "expected non-null subtype");
   return Base::getChecked(emitError, elementType.getContext(), elementType,
                           numElements);
 }
 
 bool LLVMFixedVectorType::isValidElementType(Type type) {
-  return type.isa<LLVMPointerType, LLVMPPCFP128Type>();
+  return llvm::isa<LLVMPointerType, LLVMPPCFP128Type>(type);
 }
 
 LogicalResult
 LLVMFixedVectorType::verify(function_ref<InFlightDiagnostic()> emitError,
                             Type elementType, unsigned numElements) {
   return verifyVectorConstructionInvariants<LLVMFixedVectorType>(
       emitError, elementType, numElements);
 }

 LLVMScalableVectorType::getChecked(function_ref<InFlightDiagnostic()> emitError,
                                    Type elementType, unsigned minNumElements) {
   assert(elementType && "expected non-null subtype");
   return Base::getChecked(emitError, elementType.getContext(), elementType,
                           minNumElements);
 }
 
 bool LLVMScalableVectorType::isValidElementType(Type type) {
-  if (auto intType = type.dyn_cast<IntegerType>())
+  if (auto intType = llvm::dyn_cast<IntegerType>(type))
     return intType.isSignless();
 
-  return isCompatibleFloatingPointType(type) || type.isa<LLVMPointerType>();
+  return isCompatibleFloatingPointType(type) ||
+         llvm::isa<LLVMPointerType>(type);
 }
 
 LogicalResult
 LLVMScalableVectorType::verify(function_ref<InFlightDiagnostic()> emitError,
                                Type elementType, unsigned numElements) {
   return verifyVectorConstructionInvariants<LLVMScalableVectorType>(
       emitError, elementType, numElements);
 }
 
 //===----------------------------------------------------------------------===//
 // Utility functions.
 //===----------------------------------------------------------------------===//
 
 bool mlir::LLVM::isCompatibleOuterType(Type type) {
   // clang-format off
-  if (type.isa<
+  if (llvm::isa<
       BFloat16Type,
       Float16Type,
       Float32Type,
       Float64Type,
       Float80Type,
       Float128Type,
       Float8E4M3FNType,
       Float8E5M2Type,
       LLVMArrayType,
       LLVMFunctionType,
       LLVMLabelType,
       LLVMMetadataType,
       LLVMPPCFP128Type,
       LLVMPointerType,
       LLVMStructType,
       LLVMTokenType,
       LLVMFixedVectorType,
       LLVMScalableVectorType,
       LLVMVoidType,
       LLVMX86MMXType
-    >()) {
+    >(type)) {
     // clang-format on
     return true;
   }
 
   // Only signless integers are compatible.
-  if (auto intType = type.dyn_cast<IntegerType>())
+  if (auto intType = llvm::dyn_cast<IntegerType>(type))
     return intType.isSignless();
 
   // 1D vector types are compatible.
-  if (auto vecType = type.dyn_cast<VectorType>())
+  if (auto vecType = llvm::dyn_cast<VectorType>(type))
     return vecType.getRank() == 1;
 
   return false;
 }
 
 static bool isCompatibleImpl(Type type, DenseSet<Type> &compatibleTypes) {
   if (!compatibleTypes.insert(type).second)
     return true;
bool LLVMDialect::isCompatibleType(Type type) {
   return isCompatibleImpl(type, localCompatibleTypes);
 }
 
 bool mlir::LLVM::isCompatibleType(Type type) {
   return LLVMDialect::isCompatibleType(type);
 }
 
 bool mlir::LLVM::isCompatibleFloatingPointType(Type type) {
-  return type.isa<BFloat16Type, Float16Type, Float32Type, Float64Type,
-                  Float80Type, Float128Type, LLVMPPCFP128Type>();
+  return llvm::isa<BFloat16Type, Float16Type, Float32Type, Float64Type,
+                   Float80Type, Float128Type, LLVMPPCFP128Type>(type);
 }
 
 bool mlir::LLVM::isCompatibleVectorType(Type type) {
-  if (type.isa<LLVMFixedVectorType, LLVMScalableVectorType>())
+  if (llvm::isa<LLVMFixedVectorType, LLVMScalableVectorType>(type))
     return true;
 
-  if (auto vecType = type.dyn_cast<VectorType>()) {
+  if (auto vecType = llvm::dyn_cast<VectorType>(type)) {
     if (vecType.getRank() != 1)
       return false;
     Type elementType = vecType.getElementType();
-    if (auto intType = elementType.dyn_cast<IntegerType>())
+    if (auto intType = llvm::dyn_cast<IntegerType>(elementType))
       return intType.isSignless();
-    return elementType.isa<BFloat16Type, Float16Type, Float32Type, Float64Type,
-                           Float80Type, Float128Type>();
+    return llvm::isa<BFloat16Type, Float16Type, Float32Type, Float64Type,
+                     Float80Type, Float128Type>(elementType);
   }
   return false;
 }
 
 Type mlir::LLVM::getVectorElementType(Type type) {
   return llvm::TypeSwitch<Type, Type>(type)
       .Case<LLVMFixedVectorType, LLVMScalableVectorType, VectorType>(
           [](auto ty) { return ty.getElementType(); })
return llvm::TypeSwitch<Type, llvm::ElementCount>(type)
         return llvm::ElementCount::getScalable(ty.getMinNumElements());
       })
       .Default([](Type) -> llvm::ElementCount {
         llvm_unreachable("incompatible with LLVM vector type");
       });
 }
 
 bool mlir::LLVM::isScalableVectorType(Type vectorType) {
-  assert(
-      (vectorType
-           .isa<LLVMFixedVectorType, LLVMScalableVectorType, VectorType>()) &&
+  assert((llvm::isa<LLVMFixedVectorType, LLVMScalableVectorType, VectorType>(
+             vectorType)) &&
          "expected LLVM-compatible vector type");
-  return !vectorType.isa<LLVMFixedVectorType>() &&
-         (vectorType.isa<LLVMScalableVectorType>() ||
-          vectorType.cast<VectorType>().isScalable());
+  return !llvm::isa<LLVMFixedVectorType>(vectorType) &&
+         (llvm::isa<LLVMScalableVectorType>(vectorType) ||
+          llvm::cast<VectorType>(vectorType).isScalable());
 }
 
 Type mlir::LLVM::getVectorType(Type elementType, unsigned numElements,
                                bool isScalable) {
   bool useLLVM = LLVMFixedVectorType::isValidElementType(elementType);
   bool useBuiltIn = VectorType::isValidElementType(elementType);
   (void)useBuiltIn;
   assert((useLLVM ^ useBuiltIn) && "expected LLVM-compatible fixed-vector type "
return llvm::TypeSwitch<Type, llvm::TypeSize>(type)
         assert(isCompatibleVectorType(t) &&
                "unexpected incompatible with LLVM vector type");
         llvm::TypeSize elementSize =
             getPrimitiveTypeSizeInBits(t.getElementType());
         return llvm::TypeSize(elementSize.getFixedValue() * t.getNumElements(),
                               elementSize.isScalable());
       })
       .Default([](Type ty) {
-        assert((ty.isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
+        assert((llvm::isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
                           LLVMTokenType, LLVMStructType, LLVMArrayType,
-                       LLVMPointerType, LLVMFunctionType>()) &&
+                          LLVMPointerType, LLVMFunctionType>(ty)) &&
                "unexpected missing support for primitive type");
         return llvm::TypeSize::Fixed(0);
       });
 }
 
 //===----------------------------------------------------------------------===//
 // LLVMDialect
 //===----------------------------------------------------------------------===//

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

MmaOp::inferOperandMMAType(Type operandElType, bool isAccumulator) {
   if (operandElType.isF64())
     return NVVM::MMATypes::f64;
   if (operandElType.isF16() || operandElType == half2Type)
     return NVVM::MMATypes::f16;
   if (operandElType.isF32() && isAccumulator)
     return NVVM::MMATypes::f32;
   if (operandElType.isF32() && !isAccumulator)
     return NVVM::MMATypes::tf32;
-  if (operandElType.isa<IntegerType>()) {
+  if (llvm::isa<IntegerType>(operandElType)) {
     if (isAccumulator)
       return NVVM::MMATypes::s32;
     return std::nullopt;
   }
 
-  if (auto structType = operandElType.dyn_cast<LLVM::LLVMStructType>()) {
+  if (auto structType = llvm::dyn_cast<LLVM::LLVMStructType>(operandElType)) {
     if (structType.getBody().empty())
       return std::nullopt;
     return inferOperandMMAType(structType.getBody()[0], isAccumulator);
   }
 
   return std::nullopt;
 }
 
LogicalResult MmaOp::verify() {
   }
 
   return success();
 }
 
 LogicalResult ShflOp::verify() {
   if (!(*this)->getAttrOfType<UnitAttr>("return_value_and_is_valid"))
     return success();
-  auto type = getType().dyn_cast<LLVM::LLVMStructType>();
+  auto type = llvm::dyn_cast<LLVM::LLVMStructType>(getType());
   auto elementType = (type && type.getBody().size() == 2)
-                         ? type.getBody()[1].dyn_cast<IntegerType>()
+                         ? llvm::dyn_cast<IntegerType>(type.getBody()[1])
                          : nullptr;
   if (!elementType || elementType.getWidth() != 1)
     return emitError("expected return type to be a two-element struct with "
                      "i1 as the second element");
   return success();
 }
 
 std::pair<mlir::Type, unsigned> NVVM::inferMMAType(NVVM::MMATypes type,
if (frag == NVVM::MMAFrag::a) {
     nCol = n;
   }
   assert(nRow && nCol);
   return inferMMAType(type, frag, nRow, nCol, context);
 }
 
 LogicalResult NVVM::WMMALoadOp::verify() {
   unsigned addressSpace =
-      getPtr().getType().cast<LLVM::LLVMPointerType>().getAddressSpace();
+      llvm::cast<LLVM::LLVMPointerType>(getPtr().getType()).getAddressSpace();
   if (addressSpace != 0 && addressSpace != 1 && addressSpace != 3)
     return emitOpError("expected source pointer in memory "
                        "space 0, 1, 3");
 
   if (NVVM::WMMALoadOp::getIntrinsicID(getM(), getN(), getK(), getLayout(),
                                        getEltype(), getFrag()) == 0)
     return emitOpError() << "invalid attribute combination";
   std::pair<Type, unsigned> typeInfo = inferMMATypeFromMNK(
       getEltype(), getFrag(), getM(), getN(), getK(), getContext());
   Type dstType = LLVM::LLVMStructType::getLiteral(
       getContext(), SmallVector<Type, 8>(typeInfo.second, typeInfo.first));
   if (getType() != dstType)
     return emitOpError("expected destination type is a structure of ")
            << typeInfo.second << " elements of type " << typeInfo.first;
   return success();
 }
 
 LogicalResult NVVM::WMMAStoreOp::verify() {
   unsigned addressSpace =
-      getPtr().getType().cast<LLVM::LLVMPointerType>().getAddressSpace();
+      llvm::cast<LLVM::LLVMPointerType>(getPtr().getType()).getAddressSpace();
   if (addressSpace != 0 && addressSpace != 1 && addressSpace != 3)
     return emitOpError("expected operands to be a source pointer in memory "
                        "space 0, 1, 3");
 
   if (NVVM::WMMAStoreOp::getIntrinsicID(getM(), getN(), getK(), getLayout(),
                                         getEltype()) == 0)
     return emitOpError() << "invalid attribute combination";
   std::pair<Type, unsigned> typeInfo = inferMMATypeFromMNK(
LogicalResult NVVM::WMMAMmaOp::verify() {
   if (getType() != dstType)
     return emitOpError("expected destination type is a structure of ")
            << typeInfoC.second << " elements of type " << typeInfoC.first;
   return success();
 }
 
 LogicalResult NVVM::LdMatrixOp::verify() {
   unsigned addressSpace =
-      getPtr().getType().cast<LLVM::LLVMPointerType>().getAddressSpace();
+      llvm::cast<LLVM::LLVMPointerType>(getPtr().getType()).getAddressSpace();
   if (addressSpace != 3)
     return emitOpError("expected source pointer in memory space 3");
 
   if (getNum() != 1 && getNum() != 2 && getNum() != 4)
     return emitOpError("expected num attribute to be 1, 2 or 4");
 
   Type i32 = IntegerType::get(getContext(), 32);
   if (getNum() == 1 && getType() != i32)
if (attrName == NVVMDialect::getKernelFuncAttrName()) {
     if (!isa<LLVM::LLVMFuncOp>(op)) {
       return op->emitError() << "'" << NVVMDialect::getKernelFuncAttrName()
                              << "' attribute attached to unexpected op";
     }
   }
   // If maxntid and reqntid exist, it must be an array with max 3 dim
   if (attrName == NVVMDialect::getMaxntidAttrName() ||
       attrName == NVVMDialect::getReqntidAttrName()) {
-    auto values = attr.getValue().dyn_cast<ArrayAttr>();
+    auto values = llvm::dyn_cast<ArrayAttr>(attr.getValue());
     if (!values || values.empty() || values.size() > 3)
       return op->emitError()
              << "'" << attrName
              << "' attribute must be integer array with maximum 3 index";
-    for (auto val : attr.getValue().cast<ArrayAttr>()) {
-      if (!val.dyn_cast<IntegerAttr>())
+    for (auto val : llvm::cast<ArrayAttr>(attr.getValue())) {
+      if (!llvm::dyn_cast<IntegerAttr>(val))
         return op->emitError()
                << "'" << attrName
                << "' attribute must be integer array with maximum 3 index";
     }
   }
   // If minctasm and maxnreg exist, it must be an array with max 3 dim
   if (attrName == NVVMDialect::getMinctasmAttrName() ||
       attrName == NVVMDialect::getMaxnregAttrName()) {
-    if (!attr.getValue().dyn_cast<IntegerAttr>())
+    if (!llvm::dyn_cast<IntegerAttr>(attr.getValue()))
       return op->emitError()
              << "'" << attrName << "' attribute must be integer constant";
   }
 
   return success();
 }
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/NVVMOps.cpp.inc"
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/LLVMIR/NVVMOpsAttributes.cpp.inc"

mlir/lib/Dialect/Linalg/IR/LinalgInterfaces.cpp

 //===----------------------------------------------------------------------===//
 // StructuredOpInterface implementation
 //===----------------------------------------------------------------------===//
 
 /// Helper function that creates a memref::DimOp or tensor::DimOp depending on
 /// the type of `source`.
 static Value createOrFoldDimOp(OpBuilder &b, Location loc, Value source,
                                int64_t dim) {
-  if (source.getType().isa<UnrankedMemRefType, MemRefType>())
+  if (llvm::isa<UnrankedMemRefType, MemRefType>(source.getType()))
     return b.createOrFold<memref::DimOp>(loc, source, dim);
-  if (source.getType().isa<UnrankedTensorType, RankedTensorType>())
+  if (llvm::isa<UnrankedTensorType, RankedTensorType>(source.getType()))
     return b.createOrFold<tensor::DimOp>(loc, source, dim);
   llvm_unreachable("Expected MemRefType or TensorType");
 }
 static OpFoldResult createFoldedDimOp(OpBuilder &b, Location loc, Value source,
                                       int64_t dim) {
-  auto shapedType = source.getType().cast<ShapedType>();
+  auto shapedType = llvm::cast<ShapedType>(source.getType());
   if (!shapedType.hasRank() || shapedType.isDynamicDim(dim))
     return createOrFoldDimOp(b, loc, source, dim);
   return b.getIndexAttr(shapedType.getDimSize(dim));
 }
 
 SmallVector<OpFoldResult> LinalgOp::createFlatListOfOperandDims(OpBuilder &b,
                                                                 Location loc) {
   SmallVector<OpFoldResult> res;
SmallVector<OpFoldResult> allResultDimValues =
       affine::makeComposedFoldedMultiResultAffineApply(
           rewriter, loc, resultShapesFromInputShapesMap,
           createFlatListOfOperandDims(b, loc));
   int64_t pos = 0;
   ArrayRef<AffineExpr> shapeExprs = resultShapesFromInputShapesMap.getResults();
   for (OpOperand *opOperand : getDpsInitOperands()) {
     SmallVector<OpFoldResult> shapes;
     for (int64_t dim : llvm::seq<int64_t>(0, getRank(opOperand))) {
-      auto shapedType = opOperand->get().getType().cast<ShapedType>();
+      auto shapedType = llvm::cast<ShapedType>(opOperand->get().getType());
       if (!shapedType.isDynamicDim(dim)) {
         // Static dim: Return IntegerAttr.
         shapes.push_back(b.getIndexAttr(shapedType.getDimSize(dim)));
       } else {
         // Dynamic dim: Return Value.
         OpFoldResult ofr =
             checkDimExpr.visit(shapeExprs[pos])
                 ? createOrFoldDimOp(b, loc, opOperand->get(), dim)

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

 /// ods-gen and by manually defined C++ ops. It is called by both builders and
 /// parsers and creates a block with arguments corresponding to the elemental
 /// types of `inputTypes` and `outputTypes`. All output types are asserted to be
 /// ShapedType.
 static void fillStructuredOpRegion(OpBuilder &opBuilder, Region &region,
                                    TypeRange inputTypes, TypeRange outputTypes,
                                    ArrayRef<NamedAttribute> attrs,
                                    RegionBuilderFn regionBuilder) {
-  assert(llvm::all_of(outputTypes, [](Type t) { return t.isa<ShapedType>(); }));
+  assert(llvm::all_of(outputTypes,
+                      [](Type t) { return llvm::isa<ShapedType>(t); }));
 
   // TODO: atm all operands go through getElementTypeOrSelf,
   // reconsider when we have evidence we need to.
   SmallVector<Type, 8> argTypes;
   SmallVector<Location, 8> argLocs;
   for (auto containers : {inputTypes, outputTypes}) {
     for (auto t : containers) {
       argTypes.push_back(getElementTypeOrSelf(t));
static void buildStructuredOp(OpBuilder &b, OperationState &state,
                               ValueRange inputs, ValueRange outputs,
                               ArrayRef<NamedAttribute> attributes,
                               RegionBuilderFn regionBuilder) {
   // Derive the result types if needed.
   SmallVector<Type> derivedResultTypes =
       resultTensorTypes.value_or(TypeRange());
   if (!resultTensorTypes)
     copy_if(outputs.getTypes(), std::back_inserter(derivedResultTypes),
-            [](Type type) { return type.isa<RankedTensorType>(); });
+            [](Type type) { return llvm::isa<RankedTensorType>(type); });
 
   state.addOperands(inputs);
   state.addOperands(outputs);
   state.addTypes(derivedResultTypes);
   state.addAttributes(attributes);
   state.addAttribute(
       "operand_segment_sizes",
       b.getDenseI32ArrayAttr({static_cast<int32_t>(inputs.size()),
parseCommonStructuredOpParts(OpAsmParser &parser, OperationState &result,
   if (addOperandSegmentSizes) {
     // This is a bit complex because we're trying to be backward compatible with
     // operation syntax that mix the inherent attributes and the discardable ones
     // in the same dictionary.
     // If the properties are used, we append the operand_segment_sizes there directly.
     // Otherwise we append it to the discardable attributes dictionary where it is
     // handled by the generic Operation::create(...) method.
     if (result.propertiesAttr) {
-      NamedAttrList attrs = result.propertiesAttr.cast<DictionaryAttr>();
+      NamedAttrList attrs = llvm::cast<DictionaryAttr>(result.propertiesAttr);
       attrs.append("operand_segment_sizes",
                    parser.getBuilder().getDenseI32ArrayAttr(
                        {static_cast<int32_t>(inputsOperands.size()),
                         static_cast<int32_t>(outputsOperands.size())}));
       result.propertiesAttr = attrs.getDictionary(parser.getContext());
     } else {
       result.addAttribute("operand_segment_sizes",
                           parser.getBuilder().getDenseI32ArrayAttr(
private:
   // operand returned as-is (which will presumably yield a verification
   // issue downstream).
   Value cast(Type toType, Value operand, bool isUnsignedCast) {
     OpBuilder builder = getBuilder();
     auto loc = operand.getLoc();
     return convertScalarToDtype(builder, loc, operand, toType, isUnsignedCast);
   }
 
-  bool isComplex(Value value) { return value.getType().isa<ComplexType>(); }
-  bool isFloatingPoint(Value value) { return value.getType().isa<FloatType>(); }
-  bool isInteger(Value value) { return value.getType().isa<IntegerType>(); }
+  bool isComplex(Value value) {
+    return llvm::isa<ComplexType>(value.getType());
+  }
+  bool isFloatingPoint(Value value) {
+    return llvm::isa<FloatType>(value.getType());
+  }
+  bool isInteger(Value value) {
+    return llvm::isa<IntegerType>(value.getType());
+  }
 
   OpBuilder getBuilder() {
     OpBuilder builder(context);
     builder.setInsertionPointToEnd(&block);
     return builder;
   }
 
   MLIRContext *context;
void GenericOp::print(OpAsmPrinter &p) {
   auto genericAttrNames = linalgTraitAttrNames();
 
   llvm::StringSet<> genericAttrNamesSet;
   genericAttrNamesSet.insert(genericAttrNames.begin(), genericAttrNames.end());
   SmallVector<NamedAttribute, 8> genericAttrs;
   for (auto attr : (*this)->getAttrs()) {
     if (attr.getName() == getIteratorTypesAttrName()) {
       auto iteratorTypes =
-          attr.getValue()
-              .cast<ArrayAttr>()
+          llvm::cast<ArrayAttr>(attr.getValue())
               .getAsValueRange<IteratorTypeAttr, utils::IteratorType>();
       // Convert IteratorType enums into the string representation. This is
       // needed, because tests still use the old format when 'iterator_types'
       // attribute is represented as an array of strings.
       // TODO: Remove this conversion once tests are fixed.
       SmallVector<Attribute> iteratorTypeNames =
           llvm::to_vector(llvm::map_range(
               iteratorTypes, [&](utils::IteratorType t) -> Attribute {

 }
 
 static void getGenericEffectsImpl(
     SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
         &effects,
     ValueRange results, const OpOperandVector &inputOperands,
     const OpOperandVector &outputOperands) {
   for (auto *operand : inputOperands) {
-    if (!operand->get().getType().isa<MemRefType>())
+    if (!llvm::isa<MemRefType>(operand->get().getType()))
       continue;
     effects.emplace_back(MemoryEffects::Read::get(), operand->get(),
                          SideEffects::DefaultResource::get());
   }
   for (auto *operand : outputOperands) {
-    if (!operand->get().getType().isa<MemRefType>())
+    if (!llvm::isa<MemRefType>(operand->get().getType()))
       continue;
     effects.emplace_back(MemoryEffects::Read::get(), operand->get(),
                          SideEffects::DefaultResource::get());
     effects.emplace_back(MemoryEffects::Write::get(), operand->get(),
                          SideEffects::DefaultResource::get());
   }
 }
 
LogicalResult matchAndRewrite(GenericOp genericOp,
     // Mixed semantics is not supported yet.
     if (!genericOp.hasTensorSemantics())
       return failure();
 
     // Get the argument number of the returned values. That is the operand
     // number to use for replacing uses of this operation.
     SmallVector<Value> returnedArgs;
     for (const auto &yieldVal : llvm::enumerate(yieldOp.getValues())) {
-      auto yieldArg = yieldVal.value().dyn_cast<BlockArgument>();
+      auto yieldArg = llvm::dyn_cast<BlockArgument>(yieldVal.value());
       if (!yieldArg || yieldArg.getOwner() != &body)
         return failure();
       unsigned argumentNumber = yieldArg.getArgNumber();
       Value returnedArg = genericOp->getOperand(argumentNumber);
       Type resultType = genericOp->getResult(yieldVal.index()).getType();
       // The input can have a different type than the result, e.g. a dynamic
       // input dimension can be turned into a static output dimension.
       Type returnType = returnedArg.getType();
static ParseResult parseDstStyleOp(
   // Parse `ins` and `outs`.
   SmallVector<Type, 4> inputTypes, outputTypes;
   if (parseCommonStructuredOpParts(parser, result, inputTypes, outputTypes,
                                    /*addOperandSegmentSizes=*/false))
     return failure();
 
   // Add result types.
   for (Type outputType : outputTypes) {
-    if (outputType.isa<RankedTensorType>())
+    if (llvm::isa<RankedTensorType>(outputType))
       result.addTypes(outputType);
   }
 
   // Parse required attributes.
   if (parseAttrsFn && failed(parseAttrsFn(parser, result.attributes)))
     return failure();
 
   // Parse optional attributes.
void MapOp::build(
     OpBuilder &builder, OperationState &result, ValueRange inputs, Value init,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild,
     ArrayRef<NamedAttribute> attributes) {
   build(builder, result, TypeRange{}, inputs, init);
   result.addAttributes(attributes);
 
   // Add output types for `RankedTensorType` output arguments.
   Type initType = init.getType();
-  if (initType.isa<RankedTensorType>())
+  if (llvm::isa<RankedTensorType>(initType))
     result.addTypes(initType);
 
   if (bodyBuild)
     buildGenericRegion(builder, result.location, *result.regions.front(),
                        inputs, /*outputs=*/{}, bodyBuild);
 }
 
 static void addBodyWithPayloadOp(OpAsmParser &parser, OperationState &result,
                                  const OperationName &payloadOpName,
                                  const NamedAttrList &payloadOpAttrs,
                                  ArrayRef<Value> operands,
                                  bool initFirst = false) {
   OpBuilder b(parser.getContext());
   Region *body = result.addRegion();
   Block &block = body->emplaceBlock();
   b.setInsertionPointToStart(&block);
   SmallVector<Value> bbArgs;
   for (auto &operand : operands) {
-    block.addArgument(operand.getType().cast<ShapedType>().getElementType(),
-                      b.getUnknownLoc());
+    block.addArgument(
+        llvm::cast<ShapedType>(operand.getType()).getElementType(),
   }
   SmallVector<Value> payloadOpOperands;
   // If initFirst flag is enabled, we consider init as the first position of
   // payload operands.
   if (initFirst) {
     payloadOpOperands.push_back(block.getArguments().back());
     for (const auto &arg : block.getArguments().drop_back())
       payloadOpOperands.push_back(arg);
   } else {
     payloadOpOperands = {block.getArguments().begin(),
                          block.getArguments().end()};
   }
 
   Operation *payloadOp = b.create(
       result.location, b.getStringAttr(payloadOpName.getStringRef()),
       payloadOpOperands,
-      TypeRange{
-          result.operands.back().getType().cast<ShapedType>().getElementType()},
+      TypeRange{llvm::cast<ShapedType>(result.operands.back().getType())
+                    .getElementType()},
       payloadOpAttrs);
   b.create<YieldOp>(result.location, payloadOp->getResults());
 }
 
 ParseResult MapOp::parse(OpAsmParser &parser, OperationState &result) {
   std::optional<OperationName> payloadOpName;
   NamedAttrList payloadOpAttrs;
   if (succeeded(parser.parseOptionalLBrace())) {
static Operation *findPayloadOp(Block *body, bool initFirst = false) {
   return &payload;
 }
 
 void printShortForm(OpAsmPrinter &p, Operation *payloadOp) {
   SmallVector<StringRef> elidedAttrs;
   std::string attrToElide;
   p << " { " << payloadOp->getName().getStringRef();
   for (const auto &attr : payloadOp->getAttrs()) {
-    auto fastAttr = attr.getValue().dyn_cast<mlir::arith::FastMathFlagsAttr>();
+    auto fastAttr =
+        llvm::dyn_cast<mlir::arith::FastMathFlagsAttr>(attr.getValue());
     if (fastAttr && fastAttr.getValue() == mlir::arith::FastMathFlags::none) {
       attrToElide = attr.getName().str();
       elidedAttrs.push_back(attrToElide);
       break;
     }
   }
   p.printOptionalAttrDict(payloadOp->getAttrs(), elidedAttrs);
   p << " }";
LogicalResult MapOp::verify() {
   if (getInputs().size() != blockArgs.size())
     return emitOpError() << "expects number of operands to match the arity of "
                             "mapper, but got: "
                          << getInputs().size() << " and " << blockArgs.size();
 
   // The parameters of mapper should all match the element type of inputs.
   for (const auto &[bbArgType, inputArg] :
        llvm::zip(bodyBlock->getArgumentTypes(), getInputs())) {
-    auto inputElemType = inputArg.getType().cast<ShapedType>().getElementType();
+    auto inputElemType =
+        llvm::cast<ShapedType>(inputArg.getType()).getElementType();
     if (bbArgType != inputElemType) {
       return emitOpError() << "expected element type of input " << inputElemType
                            << " to match bbArg type " << bbArgType;
     }
   }
 
   // The shape of each input must match the shape of the output.
   auto outputShape = getInit().getType().getShape();
   for (Type inputArgType : TypeRange{getInputs()}) {
-    auto inputElemShape = inputArgType.cast<ShapedType>().getShape();
+    auto inputElemShape = llvm::cast<ShapedType>(inputArgType).getShape();
     if (inputElemShape != outputShape) {
       return emitOpError() << "expected shape of input (" << inputElemShape
                            << ") to match shape of output (" << outputShape
                            << ")";
     }
   }
 
   return success();
void ReduceOp::build(
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild,
     ArrayRef<NamedAttribute> attributes) {
   build(builder, result, TypeRange{}, inputs, inits, dimensions);
   result.addAttributes(attributes);
 
   // Add output types for `RankedTensorType` output arguments.
   for (Value init : inits) {
     Type initType = init.getType();
-    if (initType.isa<RankedTensorType>())
+    if (llvm::isa<RankedTensorType>(initType))
       result.addTypes(initType);
   }
 
   if (bodyBuild)
     buildGenericRegion(builder, result.location, *result.regions.front(),
                        inputs, inits, bodyBuild);
 }
 
 SmallVector<utils::IteratorType> ReduceOp::getIteratorTypesArray() {
-  int64_t inputRank = getInputs()[0].getType().cast<ShapedType>().getRank();
+  int64_t inputRank =
+      llvm::cast<ShapedType>(getInputs()[0].getType()).getRank();
   SmallVector<utils::IteratorType> iteratorTypes(inputRank,
                                                  utils::IteratorType::parallel);
   for (int64_t reductionDim : getDimensions())
     iteratorTypes[reductionDim] = utils::IteratorType::reduction;
   return iteratorTypes;
 }
 
 ArrayAttr ReduceOp::getIndexingMaps() {
-  int64_t inputRank = getInputs()[0].getType().cast<ShapedType>().getRank();
+  int64_t inputRank =
+      llvm::cast<ShapedType>(getInputs()[0].getType()).getRank();
   SmallVector<AffineMap> affineMaps(
       getNumDpsInputs(),
       AffineMap::getMultiDimIdentityMap(inputRank, getContext()));
   AffineMap resultMap =
       AffineMap::getMultiDimIdentityMap(inputRank, getContext())
           .dropResults(getDimensions());
   for (int64_t i = 0, e = getNumDpsInits(); i < e; ++i)
     affineMaps.push_back(resultMap);
if (!payloadOp) {
     p.decreaseIndent();
   }
 }
 
 LogicalResult ReduceOp::verify() {
   ArrayRef<int64_t> dimensionsRef = getDimensions();
 
   for (int64_t i = 1; i < getNumDpsInputs(); ++i) {
-    if (getInputs()[i].getType().cast<ShapedType>().getShape() !=
-        getInputs()[0].getType().cast<ShapedType>().getShape()) {
+    if (llvm::cast<ShapedType>(getInputs()[i].getType()).getShape() !=
+        llvm::cast<ShapedType>(getInputs()[0].getType()).getShape()) {
       return emitOpError() << "expects all inputs to have the same shapes. "
                               "Shape at input-index "
                            << i
                            << " is not equal to the shape at input-index 0.";
     }
   }
   for (int64_t i = 1; i < getNumDpsInits(); ++i) {
-    if (getInits()[i].getType().cast<ShapedType>().getShape() !=
-        getInits()[0].getType().cast<ShapedType>().getShape()) {
+    if (llvm::cast<ShapedType>(getInits()[i].getType()).getShape() !=
+        llvm::cast<ShapedType>(getInits()[0].getType()).getShape()) {
       return emitOpError() << "expects all outputs to have the same shapes. "
                               "Shape at output-index "
                            << i
                            << " is not equal to the shape at output-index 0.";
     }
   }
-  auto inputType = getInputs()[0].getType().cast<ShapedType>();
-  auto initType = getInits()[0].getType().cast<ShapedType>();
+  auto inputType = llvm::cast<ShapedType>(getInputs()[0].getType());
+  auto initType = llvm::cast<ShapedType>(getInits()[0].getType());
 
   DenseSet<int64_t> dimensionsToReduce;
   for (int64_t dimension : dimensionsRef) {
     if (dimension < 0 || dimension >= inputType.getRank()) {
       return emitOpError()
              << "dimensions for reduction should be in the range [0, "
              << inputType.getRank() - 1 << "].";
     }
LogicalResult ReduceOp::verify() {
 
   Block *block = getBody();
   if (block->getNumArguments() != this->getNumOperands())
     return emitOpError()
            << "mismatching number of operands and block arguments";
 
   // Check that the first block arguments match the element type of the inputs.
   for (auto [input, bbArg] : llvm::zip(getInputs(), block->getArguments())) {
-    Type inputElementType = input.getType().cast<ShapedType>().getElementType();
+    Type inputElementType =
+        llvm::cast<ShapedType>(input.getType()).getElementType();
     if (inputElementType != bbArg.getType())
       return emitOpError()
              << "input element type " << inputElementType
              << " does not match corresponding block argument type "
              << bbArg.getType();
   }
 
   // Check that the last block arguments match the element type of the outputs.
   for (auto [output, bbArg] :
        llvm::zip(getDpsInitOperands(),
                  block->getArguments().take_back(getNumDpsInits()))) {
     auto outputElementType =
-        output->get().getType().cast<ShapedType>().getElementType();
+        llvm::cast<ShapedType>(output->get().getType()).getElementType();
     if (outputElementType != bbArg.getType())
       return emitOpError()
              << "output element type " << outputElementType
              << " does not match corresponding block argument type "
              << bbArg.getType();
   }
   return success();
 }
void TransposeOp::build(::mlir::OpBuilder &builder,
                         ArrayRef<NamedAttribute> attributes) {
   result.addOperands(input);
   result.addOperands(init);
   result.addAttribute(getPermutationAttrName(result.name), permutation);
   result.addAttributes(attributes);
 
   // Add output types for `RankedTensorType` output arguments.
   Type initType = init.getType();
-  if (initType.isa<RankedTensorType>())
+  if (llvm::isa<RankedTensorType>(initType))
     result.addTypes(initType);
 
   buildIdentityRegion(builder, result.location, *result.addRegion(), input,
                       init);
 }
 
 void TransposeOp::build(::mlir::OpBuilder &builder,
                         ::mlir::OperationState &result, Value input, Value init,
void BroadcastOp::build(::mlir::OpBuilder &builder,
                         ArrayRef<NamedAttribute> attributes) {
   result.addOperands(input);
   result.addOperands(init);
   result.addAttribute(getDimensionsAttrName(result.name), dimensions);
   result.addAttributes(attributes);
 
   // Add output types for `RankedTensorType` output arguments.
   Type initType = init.getType();
-  if (initType.isa<RankedTensorType>())
+  if (llvm::isa<RankedTensorType>(initType))
     result.addTypes(initType);
 
   buildIdentityRegion(builder, result.location, *result.addRegion(), input,
                       init);
 }
 
 void BroadcastOp::build(::mlir::OpBuilder &builder,
                         ::mlir::OperationState &result, Value input, Value init,
SmallVector<AffineExpr, 4> mlir::linalg::concat(ArrayRef<AffineExpr> a,
                                                 ArrayRef<AffineExpr> b) {
   auto rangeA = llvm::make_range(a.begin(), a.end());
   auto rangeB = llvm::make_range(b.begin(), b.end());
   auto concatRanges = llvm::concat<const AffineExpr>(rangeA, rangeB);
   return llvm::to_vector<4>(concatRanges);
 }
 
 static LogicalResult appendMangledType(llvm::raw_string_ostream &ss, Type t) {
-  if (auto memref = t.dyn_cast<MemRefType>()) {
+  if (auto memref = llvm::dyn_cast<MemRefType>(t)) {
     ss << "view";
     for (auto size : memref.getShape())
       if (size < 0)
         ss << "sx";
       else
         ss << size << "x";
     if (failed(appendMangledType(ss, memref.getElementType())))
       return failure();
     if (auto as = memref.getMemorySpace()) {
-      if (auto attr = as.dyn_cast<IntegerAttr>())
+      if (auto attr = llvm::dyn_cast<IntegerAttr>(as))
         ss << "as" << attr.getInt();
       else
         return failure();
     }
     return success();
   }
-  if (auto vec = t.dyn_cast<VectorType>()) {
+  if (auto vec = llvm::dyn_cast<VectorType>(t)) {
     ss << "vector";
     llvm::interleave(
         vec.getShape(), [&](int64_t i) { ss << i; }, [&]() { ss << "x"; });
     if (failed(appendMangledType(ss, vec.getElementType())))
       return failure();
     return success();
   } else if (t.isSignlessIntOrIndexOrFloat()) {
     ss << t;
     return success();
   }
   return failure();
 }
 
 std::string mlir::linalg::generateLibraryCallName(Operation *op) {
   assert(isa<LinalgOp>(op));
   std::string name(op->getName().getStringRef().str());
   std::string fun = "";
   for (NamedAttribute kv : op->getAttrs()) {
-    if (UnaryFnAttr ufa = kv.getValue().dyn_cast<UnaryFnAttr>()) {
+    if (UnaryFnAttr ufa = llvm::dyn_cast<UnaryFnAttr>(kv.getValue())) {
       fun = stringifyEnum(ufa.getValue()).str() + "_";
-    } else if (BinaryFnAttr bfa = kv.getValue().dyn_cast<BinaryFnAttr>()) {
+    } else if (BinaryFnAttr bfa = llvm::dyn_cast<BinaryFnAttr>(kv.getValue())) {
       fun = stringifyEnum(bfa.getValue()).str() + "_";
     }
   }
   name.reserve(128);
   std::replace(name.begin(), name.end(), '.', '_');
   llvm::raw_string_ostream ss(name);
   ss << "_" << fun;
   for (Type t : op->getOperandTypes()) {
struct EraseDeadLinalgOp : public OpInterfaceRewritePattern<LinalgOp> {
   using OpInterfaceRewritePattern<LinalgOp>::OpInterfaceRewritePattern;
 
   LogicalResult matchAndRewrite(LinalgOp op,
                                 PatternRewriter &rewriter) const override {
     for (OpOperand &opOperand : op->getOpOperands()) {
       // Linalg "inputs" may be either tensor or memref type.
       // tensor<0xelt_type> is a convention that may not always mean
       // "0 iterations". Only erase in cases we see memref<...x0x...>.
-      auto mt = opOperand.get().getType().dyn_cast<MemRefType>();
+      auto mt = llvm::dyn_cast<MemRefType>(opOperand.get().getType());
       if (!mt)
         continue;
       if (llvm::is_contained(op.getShape(&opOperand), 0)) {
         rewriter.eraseOp(op);
         return success();
       }
     }
     return failure();
LogicalResult matchAndRewrite(tensor::CastOp castOp,
     // now.
     if (castOp->getBlock() != linalgOp->getBlock())
       return failure();
 
     OpBuilder::InsertionGuard guard(rewriter);
     rewriter.setInsertionPoint(linalgOp);
 
     Location loc = linalgOp.getLoc();
-    OpResult resultValue = castOp.getSource().cast<OpResult>();
+    OpResult resultValue = llvm::cast<OpResult>(castOp.getSource());
     unsigned resultNumber = resultValue.getResultNumber();
-    auto resultType = castOp->getResult(0).getType().cast<RankedTensorType>();
+    auto resultType =
+        llvm::cast<RankedTensorType>(castOp->getResult(0).getType());
     // Replace the `outs` for the result with a `tensor.cast`. This cast is now
     // going from a more dynamic shape to a less dynamic shape. If the producer
     // for this cast, i.e. producer of the out operand, is also an operation
     // that folds with tensor.cast consumer (like this pattern), the cast will
     // continue to propagate as far up the stack as it can go.
     OpOperand *outOperand = linalgOp.getDpsInitOperand(resultNumber);
     Value newOperand =
         rewriter.create<tensor::CastOp>(loc, resultType, outOperand->get());

 /// For each of the operand in `operands` this function maps the static sizes of
 /// dimensions to their affine dim expressions.
 static void populateMap(LinalgOp linalgOp, MutableArrayRef<OpOperand> operands,
                         llvm::DenseMap<AffineExpr, int64_t> &affineExprToSize) {
   for (OpOperand &opOperand : operands) {
     if (linalgOp.isScalar(&opOperand))
       continue;
     Value src = opOperand.get();
-    auto sourceType = src.getType().cast<RankedTensorType>();
+    auto sourceType = llvm::cast<RankedTensorType>(src.getType());
     auto sourceMap = linalgOp.getMatchingIndexingMap(&opOperand);
 
     // Get the `sourceShape` of the `sourceType`. If the operand is a result of
     // `tensor.cast` operation and source of the cast operation has a static
     // shape, then assign it to the `sourceShape`.
     auto *parentOp = src.getDefiningOp();
     ArrayRef<int64_t> sourceShape = sourceType.getShape();
     if (parentOp) {
       if (auto castOp = dyn_cast<tensor::CastOp>(parentOp)) {
         Value castSource = castOp.getSource();
-        auto castSourceType = castSource.getType().dyn_cast<RankedTensorType>();
+        auto castSourceType =
+            llvm::dyn_cast<RankedTensorType>(castSource.getType());
         if (castSourceType && castSourceType.hasStaticShape())
           sourceShape = castSourceType.getShape();
       }
     }
 
     // If the source shape's dimension has a static shape, map the affine dim
     // expression to the known static size.
     for (unsigned i = 0; i < sourceShape.size(); i++) {
static void createNewOperandWithStaticSizes(
     Location loc, PatternRewriter &rewriter, OpOperand *opOperand,
     llvm::DenseMap<AffineExpr, int64_t> &affineExprToSize, LinalgOp linalgOp,
     SmallVector<Value> &newOperands, SmallVector<Type> &resultTypes,
     bool &changeNeeded) {
   Value src = opOperand->get();
   newOperands.push_back(src);
   if (linalgOp.isScalar(opOperand))
     return;
-  auto sourceType = src.getType().cast<RankedTensorType>();
+  auto sourceType = llvm::cast<RankedTensorType>(src.getType());
   Type resultType = sourceType;
   if (sourceType.hasStaticShape() && linalgOp.isDpsInit(opOperand)) {
     resultTypes.push_back(resultType);
     return;
   }
   ArrayRef<int64_t> sourceShape = sourceType.getShape();
   AffineMap sourceMap = linalgOp.getMatchingIndexingMap(opOperand);
   SmallVector<int64_t> newShape;

mlir/lib/Dialect/Linalg/IR/ValueBoundsOpInterfaceImpl.cpp

void populateBoundsForIndexValue(Operation *op, Value value,
     int64_t flatDimPos = linalgOp.getShapesToLoopsMap()
                              .getResult(indexOp.getDim())
                              .cast<AffineDimExpr>()
                              .getPosition();
     // Find the `flatDimPos`-th operand dimension.
     int64_t flatDimCtr = 0;
     for (Value operand : linalgOp->getOperands()) {
       assert(flatDimPos >= flatDimCtr && "invalid pos");
-      auto shapedType = operand.getType().cast<ShapedType>();
+      auto shapedType = llvm::cast<ShapedType>(operand.getType());
       if (flatDimPos < flatDimCtr + shapedType.getRank()) {
         cstr.bound(value) < cstr.getExpr(operand, flatDimPos - flatDimCtr);
         break;
       }
       flatDimCtr += shapedType.getRank();
     }
   }
 };

mlir/lib/Dialect/MLProgram/IR/MLProgramDialect.cpp

 #define GET_TYPEDEF_CLASSES
 #include "mlir/Dialect/MLProgram/IR/MLProgramTypes.cpp.inc"
 
 namespace {
 struct MLProgramOpAsmDialectInterface : public OpAsmDialectInterface {
   using OpAsmDialectInterface::OpAsmDialectInterface;
 
   AliasResult getAlias(Attribute attr, raw_ostream &os) const override {
-    if (attr.isa<ExternAttr>()) {
+    if (llvm::isa<ExternAttr>(attr)) {
       os << "extern";
       return AliasResult::OverridableAlias;
     }
     return AliasResult::NoAlias;
   }
 };
 } // namespace
 

mlir/lib/Dialect/MemRef/IR/MemRefMem2Reg.cpp

 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 //  AllocaOp interfaces
 //===----------------------------------------------------------------------===//
 
 static bool isSupportedElementType(Type type) {
-  return type.isa<MemRefType>() ||
+  return llvm::isa<MemRefType>(type) ||
          OpBuilder(type.getContext()).getZeroAttr(type);
 }
 
 SmallVector<MemorySlot> memref::AllocaOp::getPromotableSlots() {
   MemRefType type = getType();
   if (!isSupportedElementType(type.getElementType()))
     return {};
   if (!type.hasStaticShape())

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

 /// This is a common class used for patterns of the form
 /// "someop(memrefcast) -> someop".  It folds the source of any memref.cast
 /// into the root operation directly.
 LogicalResult mlir::memref::foldMemRefCast(Operation *op, Value inner) {
   bool folded = false;
   for (OpOperand &operand : op->getOpOperands()) {
     auto cast = operand.get().getDefiningOp<CastOp>();
     if (cast && operand.get() != inner &&
-        !cast.getOperand().getType().isa<UnrankedMemRefType>()) {
+        !llvm::isa<UnrankedMemRefType>(cast.getOperand().getType())) {
       operand.set(cast.getOperand());
       folded = true;
     }
   }
   return success(folded);
 }
 
 /// Return an unranked/ranked tensor type for the given unranked/ranked memref
 /// type.
 Type mlir::memref::getTensorTypeFromMemRefType(Type type) {
-  if (auto memref = type.dyn_cast<MemRefType>())
+  if (auto memref = llvm::dyn_cast<MemRefType>(type))
     return RankedTensorType::get(memref.getShape(), memref.getElementType());
-  if (auto memref = type.dyn_cast<UnrankedMemRefType>())
+  if (auto memref = llvm::dyn_cast<UnrankedMemRefType>(type))
     return UnrankedTensorType::get(memref.getElementType());
   return NoneType::get(type.getContext());
 }
 
 SmallVector<OpFoldResult> memref::getMixedSizes(OpBuilder &builder,
                                                 Location loc, Value value) {
-  auto memrefType = value.getType().cast<MemRefType>();
+  auto memrefType = llvm::cast<MemRefType>(value.getType());
   SmallVector<OpFoldResult> result;
   for (int64_t i = 0; i < memrefType.getRank(); ++i) {
     if (memrefType.isDynamicDim(i)) {
       Value size = builder.create<memref::DimOp>(loc, value, i);
       result.push_back(size);
     } else {
       result.push_back(builder.getIndexAttr(memrefType.getDimSize(i)));
     }
if (ofr.is<Attribute>()) {
       // this and the previous loop, but it doesn't logically make sense (we are
       // dealing with indices here) and would only strenghten the inconsistency
       // around how static indices are created (some places use getI64Attr,
       // others use getIndexAttr).
       // The workaround here is to stick to the IndexAttr type for all the
       // values, hence we recreate the attribute even when it is already static
       // to make sure the type is consistent.
       ofr = builder.getIndexAttr(
-          ofr.get<Attribute>().cast<IntegerAttr>().getInt());
+          llvm::cast<IntegerAttr>(ofr.get<Attribute>()).getInt());
       continue;
     }
     std::optional<int64_t> maybeConstant =
         getConstantIntValue(ofr.get<Value>());
     if (maybeConstant)
       ofr = builder.getIndexAttr(*maybeConstant);
   }
 }
void AllocaOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   setNameFn(getResult(), "alloca");
 }
 
 template <typename AllocLikeOp>
 static LogicalResult verifyAllocLikeOp(AllocLikeOp op) {
   static_assert(llvm::is_one_of<AllocLikeOp, AllocOp, AllocaOp>::value,
                 "applies to only alloc or alloca");
-  auto memRefType = op.getResult().getType().template dyn_cast<MemRefType>();
+  auto memRefType = llvm::dyn_cast<MemRefType>(op.getResult().getType());
   if (!memRefType)
     return op.emitOpError("result must be a memref");
 
   if (static_cast<int64_t>(op.getDynamicSizes().size()) !=
       memRefType.getNumDynamicDims())
     return op.emitOpError("dimension operand count does not equal memref "
                           "dynamic dimension count");
 
results.add<SimplifyAllocConst<AllocaOp>, SimplifyDeadAlloc<AllocaOp>>(
       context);
 }
 
 //===----------------------------------------------------------------------===//
 // ReallocOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult ReallocOp::verify() {
-  auto sourceType = getOperand(0).getType().cast<MemRefType>();
+  auto sourceType = llvm::cast<MemRefType>(getOperand(0).getType());
   MemRefType resultType = getType();
 
   // The source memref should have identity layout (or none).
   if (!sourceType.getLayout().isIdentity())
     return emitError("unsupported layout for source memref type ")
            << sourceType;
 
   // The result memref should have identity layout (or none).

 /// ```
 ///
 /// may fold into:
 ///
 /// ```
 ///   consumer %0 ... : memref<?x16xf32, affine_map<(i, j)->(16 * i + j)>>
 /// ```
 bool CastOp::canFoldIntoConsumerOp(CastOp castOp) {
-  MemRefType sourceType = castOp.getSource().getType().dyn_cast<MemRefType>();
-  MemRefType resultType = castOp.getType().dyn_cast<MemRefType>();
+  MemRefType sourceType =
+      llvm::dyn_cast<MemRefType>(castOp.getSource().getType());
+  MemRefType resultType = llvm::dyn_cast<MemRefType>(castOp.getType());
 
   // Requires ranked MemRefType.
   if (!sourceType || !resultType)
     return false;
 
   // Requires same elemental type.
   if (sourceType.getElementType() != resultType.getElementType())
     return false;
bool CastOp::canFoldIntoConsumerOp(CastOp castOp) {
 
   return true;
 }
 
 bool CastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   if (inputs.size() != 1 || outputs.size() != 1)
     return false;
   Type a = inputs.front(), b = outputs.front();
-  auto aT = a.dyn_cast<MemRefType>();
-  auto bT = b.dyn_cast<MemRefType>();
+  auto aT = llvm::dyn_cast<MemRefType>(a);
+  auto bT = llvm::dyn_cast<MemRefType>(b);
 
-  auto uaT = a.dyn_cast<UnrankedMemRefType>();
-  auto ubT = b.dyn_cast<UnrankedMemRefType>();
+  auto uaT = llvm::dyn_cast<UnrankedMemRefType>(a);
+  auto ubT = llvm::dyn_cast<UnrankedMemRefType>(b);
 
   if (aT && bT) {
     if (aT.getElementType() != bT.getElementType())
       return false;
     if (aT.getLayout() != bT.getLayout()) {
       int64_t aOffset, bOffset;
       SmallVector<int64_t, 4> aStrides, bStrides;
       if (failed(getStridesAndOffset(aT, aStrides, aOffset)) ||
struct FoldCopyOfCast : public OpRewritePattern<CopyOp> {
   using OpRewritePattern<CopyOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(CopyOp copyOp,
                                 PatternRewriter &rewriter) const override {
     bool modified = false;
 
     // Check source.
     if (auto castOp = copyOp.getSource().getDefiningOp<CastOp>()) {
-      auto fromType = castOp.getSource().getType().dyn_cast<MemRefType>();
-      auto toType = castOp.getSource().getType().dyn_cast<MemRefType>();
+      auto fromType = llvm::dyn_cast<MemRefType>(castOp.getSource().getType());
+      auto toType = llvm::dyn_cast<MemRefType>(castOp.getSource().getType());
 
       if (fromType && toType) {
         if (fromType.getShape() == toType.getShape() &&
             fromType.getElementType() == toType.getElementType()) {
           rewriter.updateRootInPlace(copyOp, [&] {
             copyOp.getSourceMutable().assign(castOp.getSource());
           });
           modified = true;
         }
       }
     }
 
     // Check target.
     if (auto castOp = copyOp.getTarget().getDefiningOp<CastOp>()) {
-      auto fromType = castOp.getSource().getType().dyn_cast<MemRefType>();
-      auto toType = castOp.getSource().getType().dyn_cast<MemRefType>();
+      auto fromType = llvm::dyn_cast<MemRefType>(castOp.getSource().getType());
+      auto toType = llvm::dyn_cast<MemRefType>(castOp.getSource().getType());
 
       if (fromType && toType) {
         if (fromType.getShape() == toType.getShape() &&
             fromType.getElementType() == toType.getElementType()) {
           rewriter.updateRootInPlace(copyOp, [&] {
             copyOp.getTargetMutable().assign(castOp.getSource());
           });
           modified = true;

 computeMemRefRankReductionMask(MemRefType originalType, MemRefType reducedType,
                                ArrayRef<OpFoldResult> sizes) {
   llvm::SmallBitVector unusedDims(originalType.getRank());
   if (originalType.getRank() == reducedType.getRank())
     return unusedDims;
 
   for (const auto &dim : llvm::enumerate(sizes))
     if (auto attr = dim.value().dyn_cast<Attribute>())
-      if (attr.cast<IntegerAttr>().getInt() == 1)
+      if (llvm::cast<IntegerAttr>(attr).getInt() == 1)
         unusedDims.set(dim.index());
 
   // Early exit for the case where the number of unused dims matches the number
   // of ranks reduced.
   if (static_cast<int64_t>(unusedDims.count()) + reducedType.getRank() ==
       originalType.getRank())
     return unusedDims;
 

 
 OpFoldResult DimOp::fold(FoldAdaptor adaptor) {
   // All forms of folding require a known index.
   auto index = adaptor.getIndex().dyn_cast_or_null<IntegerAttr>();
   if (!index)
     return {};
 
   // Folding for unranked types (UnrankedMemRefType) is not supported.
-  auto memrefType = getSource().getType().dyn_cast<MemRefType>();
+  auto memrefType = llvm::dyn_cast<MemRefType>(getSource().getType());
   if (!memrefType)
     return {};
 
   // Out of bound indices produce undefined behavior but are still valid IR.
   // Don't choke on them.
   int64_t indexVal = index.getInt();
   if (indexVal < 0 || indexVal >= memrefType.getRank())
     return {};
LogicalResult DmaStartOp::verify() {
   // Mandatory non-variadic operands are: src memref, dst memref, tag memref and
   // the number of elements.
   if (numOperands < 4)
     return emitOpError("expected at least 4 operands");
 
   // Check types of operands. The order of these calls is important: the later
   // calls rely on some type properties to compute the operand position.
   // 1. Source memref.
-  if (!getSrcMemRef().getType().isa<MemRefType>())
+  if (!llvm::isa<MemRefType>(getSrcMemRef().getType()))
     return emitOpError("expected source to be of memref type");
   if (numOperands < getSrcMemRefRank() + 4)
     return emitOpError() << "expected at least " << getSrcMemRefRank() + 4
                          << " operands";
   if (!getSrcIndices().empty() &&
       !llvm::all_of(getSrcIndices().getTypes(),
                     [](Type t) { return t.isIndex(); }))
     return emitOpError("expected source indices to be of index type");
 
   // 2. Destination memref.
-  if (!getDstMemRef().getType().isa<MemRefType>())
+  if (!llvm::isa<MemRefType>(getDstMemRef().getType()))
     return emitOpError("expected destination to be of memref type");
   unsigned numExpectedOperands = getSrcMemRefRank() + getDstMemRefRank() + 4;
   if (numOperands < numExpectedOperands)
     return emitOpError() << "expected at least " << numExpectedOperands
                          << " operands";
   if (!getDstIndices().empty() &&
       !llvm::all_of(getDstIndices().getTypes(),
                     [](Type t) { return t.isIndex(); }))
     return emitOpError("expected destination indices to be of index type");
 
   // 3. Number of elements.
   if (!getNumElements().getType().isIndex())
     return emitOpError("expected num elements to be of index type");
 
   // 4. Tag memref.
-  if (!getTagMemRef().getType().isa<MemRefType>())
+  if (!llvm::isa<MemRefType>(getTagMemRef().getType()))
     return emitOpError("expected tag to be of memref type");
   numExpectedOperands += getTagMemRefRank();
   if (numOperands < numExpectedOperands)
     return emitOpError() << "expected at least " << numExpectedOperands
                          << " operands";
   if (!getTagIndices().empty() &&
       !llvm::all_of(getTagIndices().getTypes(),
                     [](Type t) { return t.isIndex(); }))

 /// The number and type of the results are inferred from the
 /// shape of the source.
 LogicalResult ExtractStridedMetadataOp::inferReturnTypes(
     MLIRContext *context, std::optional<Location> location, ValueRange operands,
     DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   ExtractStridedMetadataOpAdaptor extractAdaptor(operands, attributes,
                                                  properties);
-  auto sourceType = extractAdaptor.getSource().getType().dyn_cast<MemRefType>();
+  auto sourceType =
+      llvm::dyn_cast<MemRefType>(extractAdaptor.getSource().getType());
   if (!sourceType)
     return failure();
 
   unsigned sourceRank = sourceType.getRank();
   IndexType indexType = IndexType::get(context);
   auto memrefType =
       MemRefType::get({}, sourceType.getElementType(),
                       MemRefLayoutAttrInterface{}, sourceType.getMemorySpace());
for (auto [maybeConstant, result] : llvm::zip(maybeConstants, values)) {
     // Don't materialize a constant if there are no uses: this would indice
     // infinite loops in the driver.
     if (result.use_empty() || maybeConstant == getAsOpFoldResult(result))
       continue;
     assert(maybeConstant.template is<Attribute>() &&
            "The constified value should be either unchanged (i.e., == result) "
            "or a constant");
     Value constantVal = rewriter.create<arith::ConstantIndexOp>(
-        loc, maybeConstant.template get<Attribute>()
-                 .template cast<IntegerAttr>()
+        loc, llvm::cast<IntegerAttr>(maybeConstant.template get<Attribute>())
                  .getInt());
     for (Operation *op : llvm::make_early_inc_range(result.getUsers())) {
       // updateRootInplace: lambda cannot capture structured bindings in C++17
       // yet.
       op->replaceUsesOfWith(result, constantVal);
       atLeastOneReplacement = true;
     }
   }

 // GenericAtomicRMWOp
 //===----------------------------------------------------------------------===//
 
 void GenericAtomicRMWOp::build(OpBuilder &builder, OperationState &result,
                                Value memref, ValueRange ivs) {
   result.addOperands(memref);
   result.addOperands(ivs);
 
-  if (auto memrefType = memref.getType().dyn_cast<MemRefType>()) {
+  if (auto memrefType = llvm::dyn_cast<MemRefType>(memref.getType())) {
     Type elementType = memrefType.getElementType();
     result.addTypes(elementType);
 
     Region *bodyRegion = result.addRegion();
     bodyRegion->push_back(new Block());
     bodyRegion->addArgument(elementType, memref.getLoc());
   }
 }
if (parser.parseOperand(memref) ||
       parser.resolveOperand(memref, memrefType, result.operands) ||
       parser.resolveOperands(ivs, indexType, result.operands))
     return failure();
 
   Region *body = result.addRegion();
   if (parser.parseRegion(*body, {}) ||
       parser.parseOptionalAttrDict(result.attributes))
     return failure();
-  result.types.push_back(memrefType.cast<MemRefType>().getElementType());
+  result.types.push_back(llvm::cast<MemRefType>(memrefType).getElementType());
   return success();
 }
 
 void GenericAtomicRMWOp::print(OpAsmPrinter &p) {
   p << ' ' << getMemref() << "[" << getIndices()
     << "] : " << getMemref().getType() << ' ';
   p.printRegion(getRegion());
   p.printOptionalAttrDict((*this)->getAttrs());

 
 static ParseResult
 parseGlobalMemrefOpTypeAndInitialValue(OpAsmParser &parser, TypeAttr &typeAttr,
                                        Attribute &initialValue) {
   Type type;
   if (parser.parseType(type))
     return failure();
 
-  auto memrefType = type.dyn_cast<MemRefType>();
+  auto memrefType = llvm::dyn_cast<MemRefType>(type);
   if (!memrefType || !memrefType.hasStaticShape())
     return parser.emitError(parser.getNameLoc())
            << "type should be static shaped memref, but got " << type;
   typeAttr = TypeAttr::get(type);
 
   if (parser.parseOptionalEqual())
     return success();
 
   if (succeeded(parser.parseOptionalKeyword("uninitialized"))) {
     initialValue = UnitAttr::get(parser.getContext());
     return success();
   }
 
   Type tensorType = getTensorTypeFromMemRefType(memrefType);
   if (parser.parseAttribute(initialValue, tensorType))
     return failure();
-  if (!initialValue.isa<ElementsAttr>())
+  if (!llvm::isa<ElementsAttr>(initialValue))
     return parser.emitError(parser.getNameLoc())
            << "initial value should be a unit or elements attribute";
   return success();
 }
 
 LogicalResult GlobalOp::verify() {
-  auto memrefType = getType().dyn_cast<MemRefType>();
+  auto memrefType = llvm::dyn_cast<MemRefType>(getType());
   if (!memrefType || !memrefType.hasStaticShape())
     return emitOpError("type should be static shaped memref, but got ")
            << getType();
 
   // Verify that the initial value, if present, is either a unit attribute or
   // an elements attribute.
   if (getInitialValue().has_value()) {
     Attribute initValue = getInitialValue().value();
-    if (!initValue.isa<UnitAttr>() && !initValue.isa<ElementsAttr>())
+    if (!llvm::isa<UnitAttr>(initValue) && !llvm::isa<ElementsAttr>(initValue))
       return emitOpError("initial value should be a unit or elements "
                          "attribute, but got ")
              << initValue;
 
     // Check that the type of the initial value is compatible with the type of
     // the global variable.
-    if (auto elementsAttr = initValue.dyn_cast<ElementsAttr>()) {
+    if (auto elementsAttr = llvm::dyn_cast<ElementsAttr>(initValue)) {
       Type initType = elementsAttr.getType();
       Type tensorType = getTensorTypeFromMemRefType(memrefType);
       if (initType != tensorType)
         return emitOpError("initial value expected to be of type ")
                << tensorType << ", but was of type " << initType;
     }
   }
 
   if (std::optional<uint64_t> alignAttr = getAlignment()) {
     uint64_t alignment = *alignAttr;
 
     if (!llvm::isPowerOf2_64(alignment))
       return emitError() << "alignment attribute value " << alignment
                          << " is not a power of 2";
   }
 
   // TODO: verify visibility for declarations.
   return success();
 }
 
 ElementsAttr GlobalOp::getConstantInitValue() {
   auto initVal = getInitialValue();
   if (getConstant() && initVal.has_value())
-    return initVal.value().cast<ElementsAttr>();
+    return llvm::cast<ElementsAttr>(initVal.value());
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // GetGlobalOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
void MemorySpaceCastOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   setNameFn(getResult(), "memspacecast");
 }
 
 bool MemorySpaceCastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   if (inputs.size() != 1 || outputs.size() != 1)
     return false;
   Type a = inputs.front(), b = outputs.front();
-  auto aT = a.dyn_cast<MemRefType>();
-  auto bT = b.dyn_cast<MemRefType>();
+  auto aT = llvm::dyn_cast<MemRefType>(a);
+  auto bT = llvm::dyn_cast<MemRefType>(b);
 
-  auto uaT = a.dyn_cast<UnrankedMemRefType>();
-  auto ubT = b.dyn_cast<UnrankedMemRefType>();
+  auto uaT = llvm::dyn_cast<UnrankedMemRefType>(a);
+  auto ubT = llvm::dyn_cast<UnrankedMemRefType>(b);
 
   if (aT && bT) {
     if (aT.getElementType() != bT.getElementType())
       return false;
     if (aT.getLayout() != bT.getLayout())
       return false;
     if (aT.getShape() != bT.getShape())
       return false;

 
 //===----------------------------------------------------------------------===//
 // RankOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult RankOp::fold(FoldAdaptor adaptor) {
   // Constant fold rank when the rank of the operand is known.
   auto type = getOperand().getType();
-  auto shapedType = type.dyn_cast<ShapedType>();
+  auto shapedType = llvm::dyn_cast<ShapedType>(type);
   if (shapedType && shapedType.hasRank())
     return IntegerAttr::get(IndexType::get(getContext()), shapedType.getRank());
   return IntegerAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // ReinterpretCastOp
 //===----------------------------------------------------------------------===//
SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
   build(b, result, resultType, source, offset, sizeValues, strideValues, attrs);
 }
 
 // TODO: ponder whether we want to allow missing trailing sizes/strides that are
 // completed automatically, like we have for subview and extract_slice.
 LogicalResult ReinterpretCastOp::verify() {
   // The source and result memrefs should be in the same memory space.
-  auto srcType = getSource().getType().cast<BaseMemRefType>();
-  auto resultType = getType().cast<MemRefType>();
+  auto srcType = llvm::cast<BaseMemRefType>(getSource().getType());
+  auto resultType = llvm::cast<MemRefType>(getType());
   if (srcType.getMemorySpace() != resultType.getMemorySpace())
     return emitError("different memory spaces specified for source type ")
            << srcType << " and result memref type " << resultType;
   if (srcType.getElementType() != resultType.getElementType())
     return emitError("different element types specified for source type ")
            << srcType << " and result memref type " << resultType;
 
   // Match sizes in result memref type and in static_sizes attribute.
FailureOr<MemRefType> ExpandShapeOp::computeExpandedType(
   return MemRefType::get(resultShape, srcType.getElementType(), *computedLayout,
                          srcType.getMemorySpace());
 }
 
 void ExpandShapeOp::build(OpBuilder &builder, OperationState &result,
                           ArrayRef<int64_t> resultShape, Value src,
                           ArrayRef<ReassociationIndices> reassociation) {
   // Only ranked memref source values are supported.
-  auto srcType = src.getType().cast<MemRefType>();
+  auto srcType = llvm::cast<MemRefType>(src.getType());
   FailureOr<MemRefType> resultType =
       ExpandShapeOp::computeExpandedType(srcType, resultShape, reassociation);
   // Failure of this assertion usually indicates a problem with the source
   // type, e.g., could not get strides/offset.
   assert(succeeded(resultType) && "could not compute layout");
   build(builder, result, *resultType, src, reassociation);
 }
 
assert(succeeded(computedLayout) &&
          "invalid source layout map or collapsing non-contiguous dims");
   return MemRefType::get(resultShape, srcType.getElementType(), *computedLayout,
                          srcType.getMemorySpace());
 }
 
 void CollapseShapeOp::build(OpBuilder &b, OperationState &result, Value src,
                             ArrayRef<ReassociationIndices> reassociation,
                             ArrayRef<NamedAttribute> attrs) {
-  auto srcType = src.getType().cast<MemRefType>();
+  auto srcType = llvm::cast<MemRefType>(src.getType());
   MemRefType resultType =
       CollapseShapeOp::computeCollapsedType(srcType, reassociation);
   build(b, result, resultType, src, attrs);
   result.addAttribute(::mlir::getReassociationAttrName(),
                       getReassociationIndicesAttribute(b, reassociation));
 }
 
 LogicalResult CollapseShapeOp::verify() {
LogicalResult matchAndRewrite(CollapseShapeOp op,
     auto cast = op.getOperand().getDefiningOp<CastOp>();
     if (!cast)
       return failure();
 
     if (!CastOp::canFoldIntoConsumerOp(cast))
       return failure();
 
     Type newResultType = CollapseShapeOp::computeCollapsedType(
-        cast.getOperand().getType().cast<MemRefType>(),
+        llvm::cast<MemRefType>(cast.getOperand().getType()),
         op.getReassociationIndices());
 
     if (newResultType == op.getResultType()) {
       rewriter.updateRootInPlace(
           op, [&]() { op.getSrcMutable().assign(cast.getSource()); });
     } else {
       Value newOp = rewriter.create<CollapseShapeOp>(
           op->getLoc(), cast.getSource(), op.getReassociationIndices());
void ReshapeOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   setNameFn(getResult(), "reshape");
 }
 
 LogicalResult ReshapeOp::verify() {
   Type operandType = getSource().getType();
   Type resultType = getResult().getType();
 
-  Type operandElementType = operandType.cast<ShapedType>().getElementType();
-  Type resultElementType = resultType.cast<ShapedType>().getElementType();
+  Type operandElementType =
+      llvm::cast<ShapedType>(operandType).getElementType();
+  Type resultElementType = llvm::cast<ShapedType>(resultType).getElementType();
   if (operandElementType != resultElementType)
     return emitOpError("element types of source and destination memref "
                        "types should be the same");
 
-  if (auto operandMemRefType = operandType.dyn_cast<MemRefType>())
+  if (auto operandMemRefType = llvm::dyn_cast<MemRefType>(operandType))
     if (!operandMemRefType.getLayout().isIdentity())
       return emitOpError("source memref type should have identity affine map");
 
-  int64_t shapeSize = getShape().getType().cast<MemRefType>().getDimSize(0);
-  auto resultMemRefType = resultType.dyn_cast<MemRefType>();
+  int64_t shapeSize =
+      llvm::cast<MemRefType>(getShape().getType()).getDimSize(0);
+  auto resultMemRefType = llvm::dyn_cast<MemRefType>(resultType);
   if (resultMemRefType) {
     if (!resultMemRefType.getLayout().isIdentity())
       return emitOpError("result memref type should have identity affine map");
     if (shapeSize == ShapedType::kDynamic)
       return emitOpError("cannot use shape operand with dynamic length to "
                          "reshape to statically-ranked memref type");
     if (shapeSize != resultMemRefType.getRank())
       return emitOpError(
return SubViewOp::inferResultType(sourceMemRefType, staticOffsets,
                                     staticSizes, staticStrides);
 }
 
 Type SubViewOp::inferRankReducedResultType(ArrayRef<int64_t> resultShape,
                                            MemRefType sourceRankedTensorType,
                                            ArrayRef<int64_t> offsets,
                                            ArrayRef<int64_t> sizes,
                                            ArrayRef<int64_t> strides) {
-  auto inferredType =
-      inferResultType(sourceRankedTensorType, offsets, sizes, strides)
-          .cast<MemRefType>();
+  auto inferredType = llvm::cast<MemRefType>(
+      inferResultType(sourceRankedTensorType, offsets, sizes, strides));
   assert(inferredType.getRank() >= static_cast<int64_t>(resultShape.size()) &&
          "expected ");
   if (inferredType.getRank() == static_cast<int64_t>(resultShape.size()))
     return inferredType;
 
   // Compute which dimensions are dropped.
   std::optional<llvm::SmallDenseSet<unsigned>> dimsToProject =
       computeRankReductionMask(inferredType.getShape(), resultShape);
   assert(dimsToProject.has_value() && "invalid rank reduction");
 
   // Compute the layout and result type.
-  auto inferredLayout = inferredType.getLayout().cast<StridedLayoutAttr>();
+  auto inferredLayout = llvm::cast<StridedLayoutAttr>(inferredType.getLayout());
   SmallVector<int64_t> rankReducedStrides;
   rankReducedStrides.reserve(resultShape.size());
   for (auto [idx, value] : llvm::enumerate(inferredLayout.getStrides())) {
     if (!dimsToProject->contains(idx))
       rankReducedStrides.push_back(value);
   }
   return MemRefType::get(resultShape, inferredType.getElementType(),
                          StridedLayoutAttr::get(inferredLayout.getContext(),
void SubViewOp::build(OpBuilder &b, OperationState &result,
                       ArrayRef<OpFoldResult> sizes,
                       ArrayRef<OpFoldResult> strides,
                       ArrayRef<NamedAttribute> attrs) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
   dispatchIndexOpFoldResults(offsets, dynamicOffsets, staticOffsets);
   dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes);
   dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides);
-  auto sourceMemRefType = source.getType().cast<MemRefType>();
+  auto sourceMemRefType = llvm::cast<MemRefType>(source.getType());
   // Structuring implementation this way avoids duplication between builders.
   if (!resultType) {
-    resultType = SubViewOp::inferResultType(sourceMemRefType, staticOffsets,
-                                            staticSizes, staticStrides)
-                     .cast<MemRefType>();
+    resultType = llvm::cast<MemRefType>(SubViewOp::inferResultType(
+        sourceMemRefType, staticOffsets, staticSizes, staticStrides));
   }
   build(b, result, resultType, source, dynamicOffsets, dynamicSizes,
         dynamicStrides, b.getDenseI64ArrayAttr(staticOffsets),
         b.getDenseI64ArrayAttr(staticSizes),
         b.getDenseI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 
if (!haveCompatibleOffsets(originalType, candidateRankReducedType))
     return SliceVerificationResult::LayoutMismatch;
 
   return SliceVerificationResult::Success;
 }
 
 template <typename OpTy>
 static LogicalResult produceSubViewErrorMsg(SliceVerificationResult result,
                                             OpTy op, Type expectedType) {
-  auto memrefType = expectedType.cast<ShapedType>();
+  auto memrefType = llvm::cast<ShapedType>(expectedType);
   switch (result) {
   case SliceVerificationResult::Success:
     return success();
   case SliceVerificationResult::RankTooLarge:
     return op.emitError("expected result rank to be smaller or equal to ")
            << "the source rank. ";
   case SliceVerificationResult::SizeMismatch:
     return op.emitError("expected result type to be ")
LogicalResult SubViewOp::verify() {
   // Verify that the base memref type has a strided layout map.
   if (!isStrided(baseType))
     return emitError("base type ") << baseType << " is not strided";
 
   // Verify result type against inferred type.
   auto expectedType = SubViewOp::inferResultType(
       baseType, getStaticOffsets(), getStaticSizes(), getStaticStrides());
 
-  auto result = isRankReducedMemRefType(expectedType.cast<MemRefType>(),
+  auto result = isRankReducedMemRefType(llvm::cast<MemRefType>(expectedType),
                                         subViewType, getMixedSizes());
   return produceSubViewErrorMsg(result, *this, expectedType);
 }
 
 raw_ostream &mlir::operator<<(raw_ostream &os, const Range &range) {
   return os << "range " << range.offset << ":" << range.size << ":"
             << range.stride;
 }

 /// than `currentSourceType`. Use this signature if `sourceType` is updated
 /// together with the result type. In this case, it is important to compute
 /// the dropped dimensions using `currentSourceType` whose strides align with
 /// `currentResultType`.
 static MemRefType getCanonicalSubViewResultType(
     MemRefType currentResultType, MemRefType currentSourceType,
     MemRefType sourceType, ArrayRef<OpFoldResult> mixedOffsets,
     ArrayRef<OpFoldResult> mixedSizes, ArrayRef<OpFoldResult> mixedStrides) {
-  auto nonRankReducedType = SubViewOp::inferResultType(sourceType, mixedOffsets,
-                                                       mixedSizes, mixedStrides)
-                                .cast<MemRefType>();
+  auto nonRankReducedType = llvm::cast<MemRefType>(SubViewOp::inferResultType(
+      sourceType, mixedOffsets, mixedSizes, mixedStrides));
   std::optional<llvm::SmallBitVector> unusedDims =
       computeMemRefRankReductionMask(currentSourceType, currentResultType,
                                      mixedSizes);
   // Return nullptr as failure mode.
   if (!unusedDims)
     return nullptr;
 
-  auto layout = nonRankReducedType.getLayout().cast<StridedLayoutAttr>();
+  auto layout = llvm::cast<StridedLayoutAttr>(nonRankReducedType.getLayout());
   SmallVector<int64_t> shape, strides;
   unsigned numDimsAfterReduction =
       nonRankReducedType.getRank() - unusedDims->count();
   shape.reserve(numDimsAfterReduction);
   strides.reserve(numDimsAfterReduction);
   for (const auto &[idx, size, stride] :
        llvm::zip(llvm::seq<unsigned>(0, nonRankReducedType.getRank()),
                  nonRankReducedType.getShape(), layout.getStrides())) {
static MemRefType getCanonicalSubViewResultType(
     ArrayRef<OpFoldResult> mixedStrides) {
   return getCanonicalSubViewResultType(currentResultType, sourceType,
                                        sourceType, mixedOffsets, mixedSizes,
                                        mixedStrides);
 }
 
 Value mlir::memref::createCanonicalRankReducingSubViewOp(
     OpBuilder &b, Location loc, Value memref, ArrayRef<int64_t> targetShape) {
-  auto memrefType = memref.getType().cast<MemRefType>();
+  auto memrefType = llvm::cast<MemRefType>(memref.getType());
   unsigned rank = memrefType.getRank();
   SmallVector<OpFoldResult> offsets(rank, b.getIndexAttr(0));
   SmallVector<OpFoldResult> sizes = getMixedSizes(b, loc, memref);
   SmallVector<OpFoldResult> strides(rank, b.getIndexAttr(1));
-  auto targetType = SubViewOp::inferRankReducedResultType(
-                        targetShape, memrefType, offsets, sizes, strides)
-                        .cast<MemRefType>();
+  auto targetType =
+      llvm::cast<MemRefType>(SubViewOp::inferRankReducedResultType(
+          targetShape, memrefType, offsets, sizes, strides));
   return b.createOrFold<memref::SubViewOp>(loc, targetType, memref, offsets,
                                            sizes, strides);
 }
 
 FailureOr<Value> SubViewOp::rankReduceIfNeeded(OpBuilder &b, Location loc,
                                                Value value,
                                                ArrayRef<int64_t> desiredShape) {
-  auto sourceMemrefType = value.getType().dyn_cast<MemRefType>();
+  auto sourceMemrefType = llvm::dyn_cast<MemRefType>(value.getType());
   assert(sourceMemrefType && "not a ranked memref type");
   auto sourceShape = sourceMemrefType.getShape();
   if (sourceShape.equals(desiredShape))
     return value;
   auto maybeRankReductionMask =
       mlir::computeRankReductionMask(sourceShape, desiredShape);
   if (!maybeRankReductionMask)
     return failure();
if (!CastOp::canFoldIntoConsumerOp(castOp))
       return failure();
 
     // Compute the SubViewOp result type after folding the MemRefCastOp. Use
     // the MemRefCastOp source operand type to infer the result type and the
     // current SubViewOp source operand type to compute the dropped dimensions
     // if the operation is rank-reducing.
     auto resultType = getCanonicalSubViewResultType(
         subViewOp.getType(), subViewOp.getSourceType(),
-        castOp.getSource().getType().cast<MemRefType>(),
+        llvm::cast<MemRefType>(castOp.getSource().getType()),
         subViewOp.getMixedOffsets(), subViewOp.getMixedSizes(),
         subViewOp.getMixedStrides());
     if (!resultType)
       return failure();
 
     Value newSubView = rewriter.create<SubViewOp>(
         subViewOp.getLoc(), resultType, castOp.getSource(),
         subViewOp.getOffsets(), subViewOp.getSizes(), subViewOp.getStrides(),
void SubViewOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                             MLIRContext *context) {
   results
       .add<OpWithOffsetSizesAndStridesConstantArgumentFolder<
                SubViewOp, SubViewReturnTypeCanonicalizer, SubViewCanonicalizer>,
            SubViewOpMemRefCastFolder, TrivialSubViewOpFolder>(context);
 }
 
 OpFoldResult SubViewOp::fold(FoldAdaptor adaptor) {
-  auto resultShapedType = getResult().getType().cast<ShapedType>();
-  auto sourceShapedType = getSource().getType().cast<ShapedType>();
+  auto resultShapedType = llvm::cast<ShapedType>(getResult().getType());
+  auto sourceShapedType = llvm::cast<ShapedType>(getSource().getType());
 
   if (resultShapedType.hasStaticShape() &&
       resultShapedType == sourceShapedType) {
     return getViewSource();
   }
 
   // Fold subview(subview(x)), where both subviews have the same size and the
   // second subview's offsets are all zero. (I.e., the second subview is a

 }
 
 void TransposeOp::build(OpBuilder &b, OperationState &result, Value in,
                         AffineMapAttr permutation,
                         ArrayRef<NamedAttribute> attrs) {
   auto permutationMap = permutation.getValue();
   assert(permutationMap);
 
-  auto memRefType = in.getType().cast<MemRefType>();
+  auto memRefType = llvm::cast<MemRefType>(in.getType());
   // Compute result type.
   MemRefType resultType = inferTransposeResultType(memRefType, permutationMap);
 
   build(b, result, resultType, in, attrs);
   result.addAttribute(TransposeOp::getPermutationAttrStrName(), permutation);
 }
 
 // transpose $in $permutation attr-dict : type($in) `to` type(results)

 }
 
 LogicalResult TransposeOp::verify() {
   if (!getPermutation().isPermutation())
     return emitOpError("expected a permutation map");
   if (getPermutation().getNumDims() != getIn().getType().getRank())
     return emitOpError("expected a permutation map of same rank as the input");
 
-  auto srcType = getIn().getType().cast<MemRefType>();
-  auto dstType = getType().cast<MemRefType>();
+  auto srcType = llvm::cast<MemRefType>(getIn().getType());
+  auto dstType = llvm::cast<MemRefType>(getType());
   auto transposedType = inferTransposeResultType(srcType, getPermutation());
   if (dstType != transposedType)
     return emitOpError("output type ")
            << dstType << " does not match transposed input type " << srcType
            << ", " << transposedType;
   return success();
 }
 
 OpFoldResult TransposeOp::fold(FoldAdaptor) {
   if (succeeded(foldMemRefCast(*this)))
     return getResult();
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // ViewOp
 //===----------------------------------------------------------------------===//
 
 void ViewOp::getAsmResultNames(function_ref<void(Value, StringRef)> setNameFn) {
   setNameFn(getResult(), "view");
 }
 
 LogicalResult ViewOp::verify() {
-  auto baseType = getOperand(0).getType().cast<MemRefType>();
+  auto baseType = llvm::cast<MemRefType>(getOperand(0).getType());
   auto viewType = getType();
 
   // The base memref should have identity layout map (or none).
   if (!baseType.getLayout().isIdentity())
     return emitError("unsupported map for base memref type ") << baseType;
 
   // The result memref should have identity layout map (or none).
   if (!viewType.getLayout().isIdentity())
LogicalResult AtomicRMWOp::verify() {
   if (getMemRefType().getRank() != getNumOperands() - 2)
     return emitOpError(
         "expects the number of subscripts to be equal to memref rank");
   switch (getKind()) {
   case arith::AtomicRMWKind::addf:
   case arith::AtomicRMWKind::maxf:
   case arith::AtomicRMWKind::minf:
   case arith::AtomicRMWKind::mulf:
-    if (!getValue().getType().isa<FloatType>())
+    if (!llvm::isa<FloatType>(getValue().getType()))
       return emitOpError() << "with kind '"
                            << arith::stringifyAtomicRMWKind(getKind())
                            << "' expects a floating-point type";
     break;
   case arith::AtomicRMWKind::addi:
   case arith::AtomicRMWKind::maxs:
   case arith::AtomicRMWKind::maxu:
   case arith::AtomicRMWKind::mins:
   case arith::AtomicRMWKind::minu:
   case arith::AtomicRMWKind::muli:
   case arith::AtomicRMWKind::ori:
   case arith::AtomicRMWKind::andi:
-    if (!getValue().getType().isa<IntegerType>())
+    if (!llvm::isa<IntegerType>(getValue().getType()))
       return emitOpError() << "with kind '"
                            << arith::stringifyAtomicRMWKind(getKind())
                            << "' expects an integer type";
     break;
   default:
     break;
   }
   return success();

mlir/lib/Dialect/MemRef/IR/ValueBoundsOpInterfaceImpl.cpp

 
 struct CastOpInterface
     : public ValueBoundsOpInterface::ExternalModel<CastOpInterface, CastOp> {
   void populateBoundsForShapedValueDim(Operation *op, Value value, int64_t dim,
                                        ValueBoundsConstraintSet &cstr) const {
     auto castOp = cast<CastOp>(op);
     assert(value == castOp.getResult() && "invalid value");
 
-    if (castOp.getResult().getType().isa<MemRefType>() &&
-        castOp.getSource().getType().isa<MemRefType>()) {
+    if (llvm::isa<MemRefType>(castOp.getResult().getType()) &&
+        llvm::isa<MemRefType>(castOp.getSource().getType())) {
       cstr.bound(value)[dim] == cstr.getExpr(castOp.getSource(), dim);
     }
   }
 };
 
 struct DimOpInterface
     : public ValueBoundsOpInterface::ExternalModel<DimOpInterface, DimOp> {
   void populateBoundsForIndexValue(Operation *op, Value value,

 
 struct RankOpInterface
     : public ValueBoundsOpInterface::ExternalModel<RankOpInterface, RankOp> {
   void populateBoundsForIndexValue(Operation *op, Value value,
                                    ValueBoundsConstraintSet &cstr) const {
     auto rankOp = cast<RankOp>(op);
     assert(value == rankOp.getResult() && "invalid value");
 
-    auto memrefType = rankOp.getMemref().getType().dyn_cast<MemRefType>();
+    auto memrefType = llvm::dyn_cast<MemRefType>(rankOp.getMemref().getType());
     if (!memrefType)
       return;
     cstr.bound(value) == memrefType.getRank();
   }
 };
 
 struct SubViewOpInterface
     : public ValueBoundsOpInterface::ExternalModel<SubViewOpInterface,

mlir/lib/Dialect/NVGPU/IR/NVGPUDialect.cpp

 #include "mlir/Dialect/NVGPU/IR/NVGPU.cpp.inc"
       >();
 }
 
 bool nvgpu::NVGPUDialect::hasSharedMemoryAddressSpace(MemRefType type) {
   Attribute memorySpace = type.getMemorySpace();
   if (!memorySpace)
     return false;
-  if (auto intAttr = memorySpace.dyn_cast<IntegerAttr>())
+  if (auto intAttr = llvm::dyn_cast<IntegerAttr>(memorySpace))
     return intAttr.getInt() == NVGPUDialect::kSharedMemoryAddressSpace;
-  if (auto gpuAttr = memorySpace.dyn_cast<gpu::AddressSpaceAttr>())
+  if (auto gpuAttr = llvm::dyn_cast<gpu::AddressSpaceAttr>(memorySpace))
     return gpuAttr.getValue() == gpu::AddressSpace::Workgroup;
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // NVGPU_DeviceAsyncCopyOp
 //===----------------------------------------------------------------------===//
 
 /// Return true if the last dimension of the MemRefType has unit stride. Also
 /// return true for memrefs with no strides.
 static bool isLastMemrefDimUnitStride(MemRefType type) {
   int64_t offset;
   SmallVector<int64_t> strides;
   if (failed(getStridesAndOffset(type, strides, offset))) {
     return false;
   }
   return strides.back() == 1;
 }
 
 LogicalResult DeviceAsyncCopyOp::verify() {
-  auto srcMemref = getSrc().getType().cast<MemRefType>();
-  auto dstMemref = getDst().getType().cast<MemRefType>();
+  auto srcMemref = llvm::cast<MemRefType>(getSrc().getType());
+  auto dstMemref = llvm::cast<MemRefType>(getDst().getType());
 
   if (!isLastMemrefDimUnitStride(srcMemref))
     return emitError("source memref most minor dim must have unit stride");
   if (!isLastMemrefDimUnitStride(dstMemref))
     return emitError("destination memref most minor dim must have unit stride");
   if (!NVGPUDialect::hasSharedMemoryAddressSpace(dstMemref))
     return emitError()
            << "destination memref must have a memory space attribute of "

 }
 
 //===----------------------------------------------------------------------===//
 // NVGPU_LdMatrixOp
 //===----------------------------------------------------------------------===//
 LogicalResult LdMatrixOp::verify() {
 
   // ldmatrix reads data from source in shared memory
-  auto srcMemref = getSrcMemref().getType().cast<MemRefType>();
+  auto srcMemref = llvm::cast<MemRefType>(getSrcMemref().getType());
 
   // ldmatrix writes data to result/destination in vector registers
-  auto resVector = getRes().getType().cast<VectorType>();
+  auto resVector = llvm::cast<VectorType>(getRes().getType());
 
   // vector register shape, element type, and bitwidth
   ArrayRef<int64_t> resShape = resVector.getShape();
   Type resType = resVector.getElementType();
   int64_t elementBitWidth = resType.getIntOrFloatBitWidth();
 
   // ldmatrix loads 32 bits into vector registers per 8-by-8 tile per thread
   int64_t numElementsPer32b = 32 / elementBitWidth;

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

 using namespace mlir::omp;
 
 namespace {
 /// Model for pointer-like types that already provide a `getElementType` method.
 template <typename T>
 struct PointerLikeModel
     : public PointerLikeType::ExternalModel<PointerLikeModel<T>, T> {
   Type getElementType(Type pointer) const {
-    return pointer.cast<T>().getElementType();
+    return llvm::cast<T>(pointer).getElementType();
   }
 };
 
 struct OpenMPDialectFoldInterface : public DialectFoldInterface {
   using DialectFoldInterface::DialectFoldInterface;
 
   bool shouldMaterializeInto(Region *region) const final {
     // Avoid folding constants across target regions
for (auto it : alignedVariables)
     if (!alignedItems.insert(it).second)
       return op->emitOpError() << "aligned variable used more than once";
 
   if (!alignmentValues)
     return success();
 
   // Check if all alignment values are positive - OpenMP 4.5 -> 2.8.1 section
   for (unsigned i = 0; i < (*alignmentValues).size(); ++i) {
-    if (auto intAttr = (*alignmentValues)[i].dyn_cast<IntegerAttr>()) {
+    if (auto intAttr = llvm::dyn_cast<IntegerAttr>((*alignmentValues)[i])) {
       if (intAttr.getValue().sle(0))
         return op->emitOpError() << "alignment should be greater than 0";
     } else {
       return op->emitOpError() << "expected integer alignment";
     }
   }
 
   return success();
static LogicalResult verifyReductionVarList(Operation *op,
   DenseSet<Value> accumulators;
   for (auto args : llvm::zip(reductionVars, *reductions)) {
     Value accum = std::get<0>(args);
 
     if (!accumulators.insert(accum).second)
       return op->emitOpError() << "accumulator variable used more than once";
 
     Type varType = accum.getType();
-    auto symbolRef = std::get<1>(args).cast<SymbolRefAttr>();
+    auto symbolRef = llvm::cast<SymbolRefAttr>(std::get<1>(args));
     auto decl =
         SymbolTable::lookupNearestSymbolFrom<ReductionDeclareOp>(op, symbolRef);
     if (!decl)
       return op->emitOpError() << "expected symbol reference " << symbolRef
                                << " to point to a reduction declaration";
 
     if (decl.getAccumulatorType() && decl.getAccumulatorType() != varType)
       return op->emitOpError()

 static void printDependVarList(OpAsmPrinter &p, Operation *op,
                                OperandRange dependVars, TypeRange dependTypes,
                                std::optional<ArrayAttr> depends) {
 
   for (unsigned i = 0, e = depends->size(); i < e; ++i) {
     if (i != 0)
       p << ", ";
     p << stringifyClauseTaskDepend(
-             (*depends)[i].cast<mlir::omp::ClauseTaskDependAttr>().getValue())
+             llvm::cast<mlir::omp::ClauseTaskDependAttr>((*depends)[i])
+                 .getValue())
       << " -> " << dependVars[i] << " : " << dependTypes[i];
   }
 }
 
 /// Verifies Depend clause
 static LogicalResult verifyDependVarList(Operation *op,
                                          std::optional<ArrayAttr> depends,
                                          OperandRange dependVars) {
static void printMapClause(OpAsmPrinter &p, Operation *op,
 
   assert(map_operands.size() == map_types.size());
 
   for (unsigned i = 0, e = map_operands.size(); i < e; i++) {
     int64_t mapTypeBits = 0x00;
     Value mapOp = map_operands[i];
     Attribute mapTypeOp = map_types[i];
 
-    assert(mapTypeOp.isa<mlir::IntegerAttr>());
-    mapTypeBits = mapTypeOp.cast<mlir::IntegerAttr>().getInt();
+    assert(llvm::isa<mlir::IntegerAttr>(mapTypeOp));
+    mapTypeBits = llvm::cast<mlir::IntegerAttr>(mapTypeOp).getInt();
 
     bool always = bitAnd(mapTypeBits,
                          llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_ALWAYS);
     bool close = bitAnd(mapTypeBits,
                         llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_CLOSE);
     bool present = bitAnd(
         mapTypeBits, llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_PRESENT);
 
if (getAtomicReductionRegion().empty())
     return success();
 
   Block &atomicReductionEntryBlock = getAtomicReductionRegion().front();
   if (atomicReductionEntryBlock.getNumArguments() != 2 ||
       atomicReductionEntryBlock.getArgumentTypes()[0] !=
           atomicReductionEntryBlock.getArgumentTypes()[1])
     return emitOpError() << "expects atomic reduction region with two "
                             "arguments of the same type";
-  auto ptrType = atomicReductionEntryBlock.getArgumentTypes()[0]
-                     .dyn_cast<PointerLikeType>();
+  auto ptrType = llvm::dyn_cast<PointerLikeType>(
+      atomicReductionEntryBlock.getArgumentTypes()[0]);
   if (!ptrType ||
       (ptrType.getElementType() && ptrType.getElementType() != getType()))
     return emitOpError() << "expects atomic reduction region arguments to "
                             "be accumulators containing the reduction type";
   return success();
 }
 
 LogicalResult ReductionOp::verify() {
LogicalResult AtomicWriteOp::verify() {
   if (auto mo = getMemoryOrderVal()) {
     if (*mo == ClauseMemoryOrderKind::Acq_rel ||
         *mo == ClauseMemoryOrderKind::Acquire) {
       return emitError(
           "memory-order must not be acq_rel or acquire for atomic writes");
     }
   }
   Type elementType =
-      getAddress().getType().cast<PointerLikeType>().getElementType();
+      llvm::cast<PointerLikeType>(getAddress().getType()).getElementType();
   if (elementType && elementType != getValue().getType())
     return emitError("address must dereference to value type");
   return verifySynchronizationHint(*this, getHintVal());
 }
 
 //===----------------------------------------------------------------------===//
 // Verifier for AtomicUpdateOp
 //===----------------------------------------------------------------------===//
if (*mo == ClauseMemoryOrderKind::Acq_rel ||
       return emitError(
           "memory-order must not be acq_rel or acquire for atomic updates");
     }
   }
 
   if (getRegion().getNumArguments() != 1)
     return emitError("the region must accept exactly one argument");
 
-  Type elementType = getX().getType().cast<PointerLikeType>().getElementType();
+  Type elementType =
+      llvm::cast<PointerLikeType>(getX().getType()).getElementType();
   if (elementType && elementType != getRegion().getArgument(0).getType()) {
     return emitError("the type of the operand must be a pointer type whose "
                      "element type is the same as that of the region argument");
   }
 
   return verifySynchronizationHint(*this, getHintVal());
 }
 

mlir/lib/Dialect/PDL/IR/PDL.cpp

 
 static void printResultsValueType(OpAsmPrinter &p, ResultsOp op,
                                   IntegerAttr index, Type resultType) {
   if (index)
     p << " -> " << resultType;
 }
 
 LogicalResult ResultsOp::verify() {
-  if (!getIndex() && getType().isa<pdl::ValueType>()) {
+  if (!getIndex() && llvm::isa<pdl::ValueType>(getType())) {
     return emitOpError() << "expected `pdl.range<value>` result type when "
                             "no index is specified, but got: "
                          << getType();
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/PDL/IR/PDLTypes.cpp

 // PDL Types
 //===----------------------------------------------------------------------===//
 
 bool PDLType::classof(Type type) {
   return llvm::isa<PDLDialect>(type.getDialect());
 }
 
 Type pdl::getRangeElementTypeOrSelf(Type type) {
-  if (auto rangeType = type.dyn_cast<RangeType>())
+  if (auto rangeType = llvm::dyn_cast<RangeType>(type))
     return rangeType.getElementType();
   return type;
 }
 
 //===----------------------------------------------------------------------===//
 // RangeType
 //===----------------------------------------------------------------------===//
 
 Type RangeType::parse(AsmParser &parser) {
   if (parser.parseLess())
     return Type();
 
   SMLoc elementLoc = parser.getCurrentLocation();
   Type elementType = parsePDLType(parser);
   if (!elementType || parser.parseGreater())
     return Type();
 
-  if (elementType.isa<RangeType>()) {
+  if (llvm::isa<RangeType>(elementType)) {
     parser.emitError(elementLoc)
         << "element of pdl.range cannot be another range, but got"
         << elementType;
     return Type();
   }
   return RangeType::get(elementType);
 }
 
 void RangeType::print(AsmPrinter &printer) const {
   printer << "<";
   (void)generatedTypePrinter(getElementType(), printer);
   printer << ">";
 }
 
 LogicalResult RangeType::verify(function_ref<InFlightDiagnostic()> emitError,
                                 Type elementType) {
-  if (!elementType.isa<PDLType>() || elementType.isa<RangeType>()) {
+  if (!llvm::isa<PDLType>(elementType) || llvm::isa<RangeType>(elementType)) {
     return emitError()
            << "expected element of pdl.range to be one of [!pdl.attribute, "
               "!pdl.operation, !pdl.type, !pdl.value], but got "
            << elementType;
   }
   return success();
 }

mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp

 //===----------------------------------------------------------------------===//
 
 void ForEachOp::build(::mlir::OpBuilder &builder, ::mlir::OperationState &state,
                       Value range, Block *successor, bool initLoop) {
   build(builder, state, range, successor);
   if (initLoop) {
     // Create the block and the loop variable.
     // FIXME: Allow passing in a proper location for the loop variable.
-    auto rangeType = range.getType().cast<pdl::RangeType>();
+    auto rangeType = llvm::cast<pdl::RangeType>(range.getType());
     state.regions.front()->emplaceBlock();
     state.regions.front()->addArgument(rangeType.getElementType(),
                                        state.location);
   }
 }
 
 ParseResult ForEachOp::parse(OpAsmParser &parser, OperationState &result) {
   // Parse the loop variable followed by type.

 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetValueTypeOp
 //===----------------------------------------------------------------------===//
 
 /// Given the result type of a `GetValueTypeOp`, return the expected input type.
 static Type getGetValueTypeOpValueType(Type type) {
   Type valueTy = pdl::ValueType::get(type.getContext());
-  return type.isa<pdl::RangeType>() ? pdl::RangeType::get(valueTy) : valueTy;
+  return llvm::isa<pdl::RangeType>(type) ? pdl::RangeType::get(valueTy)
+                                         : valueTy;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::CreateRangeOp
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseRangeType(OpAsmParser &p, TypeRange argumentTypes,
                                   Type &resultType) {

mlir/lib/Dialect/Quant/IR/QuantTypes.cpp

 
 LogicalResult
 QuantizedType::verify(function_ref<InFlightDiagnostic()> emitError,
                       unsigned flags, Type storageType, Type expressedType,
                       int64_t storageTypeMin, int64_t storageTypeMax) {
   // Verify that the storage type is integral.
   // This restriction may be lifted at some point in favor of using bf16
   // or f16 as exact representations on hardware where that is advantageous.
-  auto intStorageType = storageType.dyn_cast<IntegerType>();
+  auto intStorageType = llvm::dyn_cast<IntegerType>(storageType);
   if (!intStorageType)
     return emitError() << "storage type must be integral";
   unsigned integralWidth = intStorageType.getWidth();
 
   // Verify storage width.
   if (integralWidth == 0 || integralWidth > MaxStorageBits)
     return emitError() << "illegal storage type size: " << integralWidth;
 
unsigned QuantizedType::getStorageTypeIntegralWidth() const {
   return static_cast<ImplType *>(impl)->storageType.getIntOrFloatBitWidth();
 }
 
 Type QuantizedType::getExpressedType() const {
   return static_cast<ImplType *>(impl)->expressedType;
 }
 
 bool QuantizedType::isCompatibleExpressedType(Type candidateExpressedType) {
-  if (candidateExpressedType.isa<ShapedType>()) {
-    return candidateExpressedType.cast<ShapedType>().getElementType() ==
+  if (llvm::isa<ShapedType>(candidateExpressedType)) {
+    return llvm::cast<ShapedType>(candidateExpressedType).getElementType() ==
            getExpressedType();
   }
   return candidateExpressedType == getExpressedType();
 }
 
 QuantizedType
 QuantizedType::getQuantizedElementType(Type primitiveOrContainerType) {
-  if (primitiveOrContainerType.isa<ShapedType>()) {
+  if (llvm::isa<ShapedType>(primitiveOrContainerType)) {
     Type elementType =
-        primitiveOrContainerType.cast<ShapedType>().getElementType();
-    return elementType.dyn_cast<QuantizedType>();
+        llvm::cast<ShapedType>(primitiveOrContainerType).getElementType();
+    return llvm::dyn_cast<QuantizedType>(elementType);
   }
-  return primitiveOrContainerType.dyn_cast<QuantizedType>();
+  return llvm::dyn_cast<QuantizedType>(primitiveOrContainerType);
 }
 
 Type QuantizedType::castFromStorageType(Type candidateType) {
   if (candidateType == getStorageType()) {
     // i.e. i32 -> quant<"uniform[i8:f32]{1.0}">
     return *this;
   }
-  if (candidateType.isa<RankedTensorType>()) {
+  if (llvm::isa<RankedTensorType>(candidateType)) {
     // i.e. tensor<4xi8> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
     return RankedTensorType::get(
-        candidateType.cast<RankedTensorType>().getShape(), getStorageType());
+        llvm::cast<RankedTensorType>(candidateType).getShape(),
+        getStorageType());
   }
-  if (candidateType.isa<UnrankedTensorType>()) {
+  if (llvm::isa<UnrankedTensorType>(candidateType)) {
     // i.e. tensor<i8> -> tensor<!quant<"uniform[i8:f32]{1.0}">>
     return UnrankedTensorType::get(getStorageType());
   }
-  if (candidateType.isa<VectorType>()) {
+  if (llvm::isa<VectorType>(candidateType)) {
     // i.e. tensor<4xi8> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
-    return VectorType::get(candidateType.cast<VectorType>().getShape(),
+    return VectorType::get(llvm::cast<VectorType>(candidateType).getShape(),
                            getStorageType());
   }
 
   return nullptr;
 }
 
 Type QuantizedType::castToStorageType(Type quantizedType) {
-  if (quantizedType.isa<QuantizedType>()) {
+  if (llvm::isa<QuantizedType>(quantizedType)) {
     // i.e. quant<"uniform[i8:f32]{1.0}"> -> i8
-    return quantizedType.cast<QuantizedType>().getStorageType();
+    return llvm::cast<QuantizedType>(quantizedType).getStorageType();
   }
-  if (quantizedType.isa<ShapedType>()) {
+  if (llvm::isa<ShapedType>(quantizedType)) {
     // i.e. tensor<4xi8> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
-    ShapedType sType = quantizedType.cast<ShapedType>();
-    if (!sType.getElementType().isa<QuantizedType>()) {
+    ShapedType sType = llvm::cast<ShapedType>(quantizedType);
+    if (!llvm::isa<QuantizedType>(sType.getElementType())) {
       return nullptr;
     }
     Type storageType =
-        sType.getElementType().cast<QuantizedType>().getStorageType();
-    if (quantizedType.isa<RankedTensorType>()) {
+        llvm::cast<QuantizedType>(sType.getElementType()).getStorageType();
+    if (llvm::isa<RankedTensorType>(quantizedType)) {
       return RankedTensorType::get(sType.getShape(), storageType);
     }
-    if (quantizedType.isa<UnrankedTensorType>()) {
+    if (llvm::isa<UnrankedTensorType>(quantizedType)) {
       return UnrankedTensorType::get(storageType);
     }
-    if (quantizedType.isa<VectorType>()) {
+    if (llvm::isa<VectorType>(quantizedType)) {
       return VectorType::get(sType.getShape(), storageType);
     }
   }
 
   return nullptr;
 }
 
 Type QuantizedType::castFromExpressedType(Type candidateType) {
   if (candidateType == getExpressedType()) {
     // i.e. f32 -> quant<"uniform[i8:f32]{1.0}">
     return *this;
   }
-  if (candidateType.isa<ShapedType>()) {
-    ShapedType candidateShapedType = candidateType.cast<ShapedType>();
+  if (llvm::isa<ShapedType>(candidateType)) {
+    ShapedType candidateShapedType = llvm::cast<ShapedType>(candidateType);
     if (candidateShapedType.getElementType() != getExpressedType()) {
       return nullptr;
     }
 
-    if (candidateType.isa<RankedTensorType>()) {
+    if (llvm::isa<RankedTensorType>(candidateType)) {
       // i.e. tensor<4xf32> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
       return RankedTensorType::get(candidateShapedType.getShape(), *this);
     }
-    if (candidateType.isa<UnrankedTensorType>()) {
+    if (llvm::isa<UnrankedTensorType>(candidateType)) {
       // i.e. tensor<xf32> -> tensor<x!quant<"uniform[i8:f32]{1.0}">>
       return UnrankedTensorType::get(*this);
     }
-    if (candidateType.isa<VectorType>()) {
+    if (llvm::isa<VectorType>(candidateType)) {
       // i.e. tensor<4xf32> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
       return VectorType::get(candidateShapedType.getShape(), *this);
     }
   }
 
   return nullptr;
 }
 
 Type QuantizedType::castToExpressedType(Type quantizedType) {
-  if (quantizedType.isa<QuantizedType>()) {
+  if (llvm::isa<QuantizedType>(quantizedType)) {
     // i.e. quant<"uniform[i8:f32]{1.0}"> -> f32
-    return quantizedType.cast<QuantizedType>().getExpressedType();
+    return llvm::cast<QuantizedType>(quantizedType).getExpressedType();
   }
-  if (quantizedType.isa<ShapedType>()) {
+  if (llvm::isa<ShapedType>(quantizedType)) {
     // i.e. tensor<4xi8> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
-    ShapedType sType = quantizedType.cast<ShapedType>();
-    if (!sType.getElementType().isa<QuantizedType>()) {
+    ShapedType sType = llvm::cast<ShapedType>(quantizedType);
+    if (!llvm::isa<QuantizedType>(sType.getElementType())) {
       return nullptr;
     }
     Type expressedType =
-        sType.getElementType().cast<QuantizedType>().getExpressedType();
-    if (quantizedType.isa<RankedTensorType>()) {
+        llvm::cast<QuantizedType>(sType.getElementType()).getExpressedType();
+    if (llvm::isa<RankedTensorType>(quantizedType)) {
       return RankedTensorType::get(sType.getShape(), expressedType);
     }
-    if (quantizedType.isa<UnrankedTensorType>()) {
+    if (llvm::isa<UnrankedTensorType>(quantizedType)) {
       return UnrankedTensorType::get(expressedType);
     }
-    if (quantizedType.isa<VectorType>()) {
+    if (llvm::isa<VectorType>(quantizedType)) {
       return VectorType::get(sType.getShape(), expressedType);
     }
   }
 
   return nullptr;
 }
 
 Type QuantizedType::castExpressedToStorageType(Type candidateType) {
AnyQuantizedType::verify(function_ref<InFlightDiagnostic()> emitError,
   if (failed(QuantizedType::verify(emitError, flags, storageType, expressedType,
                                    storageTypeMin, storageTypeMax))) {
     return failure();
   }
 
   // Verify that the expressed type is floating point.
   // If this restriction is ever eliminated, the parser/printer must be
   // extended.
-  if (expressedType && !expressedType.isa<FloatType>())
+  if (expressedType && !llvm::isa<FloatType>(expressedType))
     return emitError() << "expressed type must be floating point";
 
   return success();
 }
 
 UniformQuantizedType UniformQuantizedType::get(unsigned flags, Type storageType,
                                                Type expressedType, double scale,
                                                int64_t zeroPoint,
LogicalResult UniformQuantizedType::verify(
   // Uniform quantization requires fully expressed parameters, including
   // expressed type.
   if (!expressedType)
     return emitError() << "uniform quantization requires expressed type";
 
   // Verify that the expressed type is floating point.
   // If this restriction is ever eliminated, the parser/printer must be
   // extended.
-  if (!expressedType.isa<FloatType>())
+  if (!llvm::isa<FloatType>(expressedType))
     return emitError() << "expressed type must be floating point";
 
   // Verify scale.
   if (scale <= 0.0 || std::isinf(scale) || std::isnan(scale))
     return emitError() << "illegal scale: " << scale;
 
   return success();
 }
LogicalResult UniformQuantizedPerAxisType::verify(
   // Uniform quantization requires fully expressed parameters, including
   // expressed type.
   if (!expressedType)
     return emitError() << "uniform quantization requires expressed type";
 
   // Verify that the expressed type is floating point.
   // If this restriction is ever eliminated, the parser/printer must be
   // extended.
-  if (!expressedType.isa<FloatType>())
+  if (!llvm::isa<FloatType>(expressedType))
     return emitError() << "expressed type must be floating point";
 
   // Ensure that the number of scales and zeroPoints match.
   if (scales.size() != zeroPoints.size())
     return emitError() << "illegal number of scales and zeroPoints: "
                        << scales.size() << ", " << zeroPoints.size();
 
   // Verify scale.

 }
 
 LogicalResult
 CalibratedQuantizedType::verify(function_ref<InFlightDiagnostic()> emitError,
                                 Type expressedType, double min, double max) {
   // Verify that the expressed type is floating point.
   // If this restriction is ever eliminated, the parser/printer must be
   // extended.
-  if (!expressedType.isa<FloatType>())
+  if (!llvm::isa<FloatType>(expressedType))
     return emitError() << "expressed type must be floating point";
   if (max <= min)
     return emitError() << "illegal min and max: (" << min << ":" << max << ")";
 
   return success();
 }
 
 double CalibratedQuantizedType::getMin() const { return getImpl()->min; }
 
 double CalibratedQuantizedType::getMax() const { return getImpl()->max; }

mlir/lib/Dialect/Quant/IR/TypeParser.cpp

static void printCalibratedQuantizedType(CalibratedQuantizedType type,
                                          DialectAsmPrinter &out) {
   out << "calibrated<" << type.getExpressedType();
   out << "<" << type.getMin() << ":" << type.getMax() << ">";
   out << ">";
 }
 
 /// Print a type registered to this dialect.
 void QuantizationDialect::printType(Type type, DialectAsmPrinter &os) const {
-  if (auto anyType = type.dyn_cast<AnyQuantizedType>())
+  if (auto anyType = llvm::dyn_cast<AnyQuantizedType>(type))
     printAnyQuantizedType(anyType, os);
-  else if (auto uniformType = type.dyn_cast<UniformQuantizedType>())
+  else if (auto uniformType = llvm::dyn_cast<UniformQuantizedType>(type))
     printUniformQuantizedType(uniformType, os);
-  else if (auto perAxisType = type.dyn_cast<UniformQuantizedPerAxisType>())
+  else if (auto perAxisType = llvm::dyn_cast<UniformQuantizedPerAxisType>(type))
     printUniformQuantizedPerAxisType(perAxisType, os);
-  else if (auto calibratedType = type.dyn_cast<CalibratedQuantizedType>())
+  else if (auto calibratedType = llvm::dyn_cast<CalibratedQuantizedType>(type))
     printCalibratedQuantizedType(calibratedType, os);
   else
     llvm_unreachable("Unhandled quantized type");
 }

mlir/lib/Dialect/SCF/IR/SCF.cpp

if (parser.parseOptionalAttrDict(result.attributes))
     return failure();
 
   return success();
 }
 
 Region &ForOp::getLoopBody() { return getRegion(); }
 
 ForOp mlir::scf::getForInductionVarOwner(Value val) {
-  auto ivArg = val.dyn_cast<BlockArgument>();
+  auto ivArg = llvm::dyn_cast<BlockArgument>(val);
   if (!ivArg)
     return ForOp();
   assert(ivArg.getOwner() && "unlinked block argument");
   auto *containingOp = ivArg.getOwner()->getParentOp();
   return dyn_cast_or_null<ForOp>(containingOp);
 }
 
 /// Return operands used when entering the region at 'index'. These operands
for (auto &yieldingOp : terminator.getYieldingOps()) {
     Value src = parallelInsertSliceOp.getSource();
 
     auto getMappedValues = [&](ValueRange values) {
       return llvm::to_vector(llvm::map_range(
           values, [&](Value value) { return mapping.lookupOrDefault(value); }));
     };
 
     Value srcVal = mapping.lookupOrDefault(src);
-    if (srcVal.getType().isa<TensorType>()) {
+    if (llvm::isa<TensorType>(srcVal.getType())) {
       results.push_back(rewriter.create<tensor::InsertSliceOp>(
           forallOp.getLoc(), dst.getType(), srcVal,
           mapping.lookupOrDefault(dst),
           getMappedValues(parallelInsertSliceOp.getOffsets()),
           getMappedValues(parallelInsertSliceOp.getSizes()),
           getMappedValues(parallelInsertSliceOp.getStrides()),
           parallelInsertSliceOp.getStaticOffsets(),
           parallelInsertSliceOp.getStaticSizes(),

 
 /// Perform a replacement of one iter OpOperand of an scf.for to the
 /// `replacement` value which is expected to be the source of a tensor.cast.
 /// tensor.cast ops are inserted inside the block to account for the type cast.
 static SmallVector<Value>
 replaceTensorCastForOpIterArg(PatternRewriter &rewriter, OpOperand &operand,
                               Value replacement) {
   Type oldType = operand.get().getType(), newType = replacement.getType();
-  assert(oldType.isa<RankedTensorType>() && newType.isa<RankedTensorType>() &&
+  assert(llvm::isa<RankedTensorType>(oldType) &&
+         llvm::isa<RankedTensorType>(newType) &&
          "expected ranked tensor types");
 
   // 1. Create new iter operands, exactly 1 is replaced.
   ForOp forOp = cast<ForOp>(operand.getOwner());
   assert(operand.getOperandNumber() >= forOp.getNumControlOperands() &&
          "expected an iter OpOperand");
   assert(operand.get().getType() != replacement.getType() &&
          "Expected a different type");
LogicalResult matchAndRewrite(ForOp forOp,
     Location loc = forOp.getLoc();
     DenseMap<Value, Value> replacements;
     for (BlockArgument bbArg : forOp.getRegionIterArgs()) {
       unsigned idx = bbArg.getArgNumber() - /*numIv=*/1;
       auto yieldOp =
           cast<scf::YieldOp>(forOp.getRegion().front().getTerminator());
       Value yieldVal = yieldOp->getOperand(idx);
       auto tensorLoadOp = yieldVal.getDefiningOp<bufferization::ToTensorOp>();
-      bool isTensor = bbArg.getType().isa<TensorType>();
+      bool isTensor = llvm::isa<TensorType>(bbArg.getType());
 
       bufferization::ToMemrefOp tensorToMemref;
       // Either bbArg has no use or it has a single buffer_cast use.
       if (bbArg.hasOneUse())
         tensorToMemref =
             dyn_cast<bufferization::ToMemrefOp>(*bbArg.getUsers().begin());
       if (!isTensor || !tensorLoadOp || (!bbArg.use_empty() && !tensorToMemref))
         continue;
if (terminator.getRegion().empty())
     builder.createBlock(&terminator.getRegion());
 }
 
 InParallelOp ForallOp::getTerminator() {
   return cast<InParallelOp>(getBody()->getTerminator());
 }
 
 ForallOp mlir::scf::getForallOpThreadIndexOwner(Value val) {
-  auto tidxArg = val.dyn_cast<BlockArgument>();
+  auto tidxArg = llvm::dyn_cast<BlockArgument>(val);
   if (!tidxArg)
     return ForallOp();
   assert(tidxArg.getOwner() && "unlinked block argument");
   auto *containingOp = tidxArg.getOwner()->getParentOp();
   return dyn_cast<ForallOp>(containingOp);
 }
 
 namespace {
 /// Fold tensor.dim(forall shared_outs(... = %t)) to tensor.dim(%t).
 struct DimOfForallOp : public OpRewritePattern<tensor::DimOp> {
   using OpRewritePattern<tensor::DimOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tensor::DimOp dimOp,
                                 PatternRewriter &rewriter) const final {
     auto forallOp = dimOp.getSource().getDefiningOp<ForallOp>();
     if (!forallOp)
       return failure();
     Value sharedOut =
-        forallOp.getTiedOpOperand(dimOp.getSource().cast<OpResult>())->get();
+        forallOp.getTiedOpOperand(llvm::cast<OpResult>(dimOp.getSource()))
+            ->get();
     rewriter.updateRootInPlace(
         dimOp, [&]() { dimOp.getSourceMutable().assign(sharedOut); });
     return success();
   }
 };
 
 class ForallOpControlOperandsFolder : public OpRewritePattern<ForallOp> {
 public:
OpResult InParallelOp::getParentResult(int64_t idx) {
   return getOperation()->getParentOp()->getResult(idx);
 }
 
 SmallVector<BlockArgument> InParallelOp::getDests() {
   return llvm::to_vector<4>(
       llvm::map_range(getYieldingOps(), [](Operation &op) {
         // Add new ops here as needed.
         auto insertSliceOp = cast<tensor::ParallelInsertSliceOp>(&op);
-        return insertSliceOp.getDest().cast<BlockArgument>();
+        return llvm::cast<BlockArgument>(insertSliceOp.getDest());
       }));
 }
 
 llvm::iterator_range<Block::iterator> InParallelOp::getYieldingOps() {
   return getRegion().front().getOperations();
 }
 
 //===----------------------------------------------------------------------===//
void IfOp::getSuccessorRegions(std::optional<unsigned> index,
 
   // Don't consider the else region if it is empty.
   Region *elseRegion = &this->getElseRegion();
   if (elseRegion->empty())
     elseRegion = nullptr;
 
   // Otherwise, the successor is dependent on the condition.
   bool condition;
-  if (auto condAttr = operands.front().dyn_cast_or_null<IntegerAttr>()) {
+  if (auto condAttr = llvm::dyn_cast_or_null<IntegerAttr>(operands.front())) {
     condition = condAttr.getValue().isOne();
   } else {
     // If the condition isn't constant, both regions may be executed.
     regions.push_back(RegionSuccessor(&getThenRegion()));
     // If the else region does not exist, it is not a viable successor.
     if (elseRegion)
       regions.push_back(RegionSuccessor(elseRegion));
     return;
LogicalResult IfOp::fold(FoldAdaptor adaptor,
   getElseRegion().getBlocks().splice(getElseRegion().getBlocks().begin(),
                                      getThenRegion().getBlocks(), thenBlock);
   return success();
 }
 
 void IfOp::getRegionInvocationBounds(
     ArrayRef<Attribute> operands,
     SmallVectorImpl<InvocationBounds> &invocationBounds) {
-  if (auto cond = operands[0].dyn_cast_or_null<BoolAttr>()) {
+  if (auto cond = llvm::dyn_cast_or_null<BoolAttr>(operands[0])) {
     // If the condition is known, then one region is known to be executed once
     // and the other zero times.
     invocationBounds.emplace_back(0, cond.getValue() ? 1 : 0);
     invocationBounds.emplace_back(0, cond.getValue() ? 0 : 1);
   } else {
     // Non-constant condition. Each region may be executed 0 or 1 times.
     invocationBounds.assign(2, {0, 1});
   }
LogicalResult matchAndRewrite(IfOp op,
     // only permit combining if the value yielded when the condition
     // is false in the outer scf.if is the same value yielded when the
     // inner scf.if condition is false.
     // Note that the array access to elseYield will not go out of bounds
     // since it must have the same length as thenYield, since they both
     // come from the same scf.if.
     for (const auto &tup : llvm::enumerate(thenYield)) {
       if (tup.value().getDefiningOp() == nestedIf) {
-        auto nestedIdx = tup.value().cast<OpResult>().getResultNumber();
+        auto nestedIdx = llvm::cast<OpResult>(tup.value()).getResultNumber();
         if (nestedIf.elseYield().getOperand(nestedIdx) !=
             elseYield[tup.index()]) {
           return failure();
         }
         // If the correctness test passes, we will yield
         // corresponding value from the inner scf.if
         thenYield[tup.index()] = nestedIf.thenYield().getOperand(nestedIdx);
         continue;
void ParallelOp::print(OpAsmPrinter &p) {
   p.printOptionalAttrDict(
       (*this)->getAttrs(),
       /*elidedAttrs=*/ParallelOp::getOperandSegmentSizeAttr());
 }
 
 Region &ParallelOp::getLoopBody() { return getRegion(); }
 
 ParallelOp mlir::scf::getParallelForInductionVarOwner(Value val) {
-  auto ivArg = val.dyn_cast<BlockArgument>();
+  auto ivArg = llvm::dyn_cast<BlockArgument>(val);
   if (!ivArg)
     return ParallelOp();
   assert(ivArg.getOwner() && "unlinked block argument");
   auto *containingOp = ivArg.getOwner()->getParentOp();
   return dyn_cast<ParallelOp>(containingOp);
 }
 
 namespace {
void WhileOp::getSuccessorRegions(std::optional<unsigned> index,
   // The body region always branches back to the condition region.
   if (*index == 1) {
     regions.emplace_back(&getBefore(), getBefore().getArguments());
     return;
   }
 
   // Try to narrow the successor to the condition region.
   assert(!operands.empty() && "expected at least one operand");
-  auto cond = operands[0].dyn_cast_or_null<BoolAttr>();
+  auto cond = llvm::dyn_cast_or_null<BoolAttr>(operands[0]);
   if (!cond || !cond.getValue())
     regions.emplace_back(getResults());
   if (!cond || cond.getValue())
     regions.emplace_back(&getAfter(), getAfter().getArguments());
 }
 
 /// Parses a `while` op.
 ///
for (const auto &it :
         canSimplify = true;
         break;
       }
       // If the i-th yield operand is k-th after block argument, then we check
       // if the (k+1)-th condition op operand is equal to either the i-th before
       // block argument or the initial value of i-th before block argument. If
       // the comparison results `true`, i-th before block argument is a loop
       // invariant.
-      auto yieldOpBlockArg = yieldOpArg.dyn_cast<BlockArgument>();
+      auto yieldOpBlockArg = llvm::dyn_cast<BlockArgument>(yieldOpArg);
       if (yieldOpBlockArg && yieldOpBlockArg.getOwner() == &afterBlock) {
         Value condOpArg = condOpArgs[yieldOpBlockArg.getArgNumber()];
         if (condOpArg == beforeBlockArgs[index] || condOpArg == initVal) {
           canSimplify = true;
           break;
         }
       }
     }
for (const auto &it :
         beforeBlockInitValMap.insert({index, initVal});
         continue;
       } else {
         // If the i-th yield operand is k-th after block argument, then we check
         // if the (k+1)-th condition op operand is equal to either the i-th
         // before block argument or the initial value of i-th before block
         // argument. If the comparison results `true`, i-th before block
         // argument is a loop invariant.
-        auto yieldOpBlockArg = yieldOpArg.dyn_cast<BlockArgument>();
+        auto yieldOpBlockArg = llvm::dyn_cast<BlockArgument>(yieldOpArg);
         if (yieldOpBlockArg && yieldOpBlockArg.getOwner() == &afterBlock) {
           Value condOpArg = condOpArgs[yieldOpBlockArg.getArgNumber()];
           if (condOpArg == beforeBlockArgs[index] || condOpArg == initVal) {
             beforeBlockInitValMap.insert({index, initVal});
             continue;
           }
         }
       }
void IndexSwitchOp::getSuccessorRegions(
     SmallVectorImpl<RegionSuccessor> &successors) {
   // All regions branch back to the parent op.
   if (index) {
     successors.emplace_back(getResults());
     return;
   }
 
   // If a constant was not provided, all regions are possible successors.
-  auto operandValue = operands.front().dyn_cast_or_null<IntegerAttr>();
+  auto operandValue = llvm::dyn_cast_or_null<IntegerAttr>(operands.front());
   if (!operandValue) {
     for (Region &caseRegion : getCaseRegions())
       successors.emplace_back(&caseRegion);
     successors.emplace_back(&getDefaultRegion());
     return;
   }
 
   // Otherwise, try to find a case with a matching value. If not, the default
   // region is the only successor.
   for (auto [caseValue, caseRegion] : llvm::zip(getCases(), getCaseRegions())) {
     if (caseValue == operandValue.getInt()) {
       successors.emplace_back(&caseRegion);
       return;
     }
   }
   successors.emplace_back(&getDefaultRegion());
 }
 
 void IndexSwitchOp::getRegionInvocationBounds(
     ArrayRef<Attribute> operands, SmallVectorImpl<InvocationBounds> &bounds) {
-  auto operandValue = operands.front().dyn_cast_or_null<IntegerAttr>();
+  auto operandValue = llvm::dyn_cast_or_null<IntegerAttr>(operands.front());
   if (!operandValue) {
     // All regions are invoked at most once.
     bounds.append(getNumRegions(), InvocationBounds(/*lb=*/0, /*ub=*/1));
     return;
   }
 
   unsigned liveIndex = getNumRegions() - 1;
   const auto *it = llvm::find(getCases(), operandValue.getInt());

mlir/lib/Dialect/SCF/IR/ValueBoundsOpInterfaceImpl.cpp

struct ForOpInterface
     : public ValueBoundsOpInterface::ExternalModel<ForOpInterface, ForOp> {
 
   /// Populate bounds of values/dimensions for iter_args/OpResults.
   static void populateIterArgBounds(scf::ForOp forOp, Value value,
                                     std::optional<int64_t> dim,
                                     ValueBoundsConstraintSet &cstr) {
     // `value` is an iter_arg or an OpResult.
     int64_t iterArgIdx;
-    if (auto iterArg = value.dyn_cast<BlockArgument>()) {
+    if (auto iterArg = llvm::dyn_cast<BlockArgument>(value)) {
       iterArgIdx = iterArg.getArgNumber() - forOp.getNumInductionVars();
     } else {
-      iterArgIdx = value.cast<OpResult>().getResultNumber();
+      iterArgIdx = llvm::cast<OpResult>(value).getResultNumber();
     }
 
     // An EQ constraint can be added if the yielded value (dimension size)
     // equals the corresponding block argument (dimension size).
     assert(forOp.getLoopBody().hasOneBlock() &&
            "multiple blocks not supported");
     Value yieldedValue =
         cast<scf::YieldOp>(forOp.getLoopBody().front().getTerminator())
static void populateIterArgBounds(scf::ForOp forOp, Value value,
 
     // Compute EQ bound for yielded value.
     AffineMap bound;
     ValueDimList boundOperands;
     LogicalResult status = ValueBoundsConstraintSet::computeBound(
         bound, boundOperands, BoundType::EQ, yieldedValue, dim,
         [&](Value v, std::optional<int64_t> d) {
           // Stop when reaching a block argument of the loop body.
-          if (auto bbArg = v.dyn_cast<BlockArgument>())
+          if (auto bbArg = llvm::dyn_cast<BlockArgument>(v))
             return bbArg.getOwner()->getParentOp() == forOp;
           // Stop when reaching a value that is defined outside of the loop. It
           // is impossible to reach an iter_arg from there.
           Operation *op = v.getDefiningOp();
           return forOp.getLoopBody().findAncestorOpInRegion(*op) == nullptr;
         });
     if (failed(status))
       return;

mlir/lib/Dialect/SPIRV/IR/SPIRVAttributes.cpp

spirv::InterfaceVarABIAttr::get(IntegerAttr descriptorSet, IntegerAttr binding,
   return Base::get(context, descriptorSet, binding, storageClass);
 }
 
 StringRef spirv::InterfaceVarABIAttr::getKindName() {
   return "interface_var_abi";
 }
 
 uint32_t spirv::InterfaceVarABIAttr::getBinding() {
-  return getImpl()->binding.cast<IntegerAttr>().getInt();
+  return llvm::cast<IntegerAttr>(getImpl()->binding).getInt();
 }
 
 uint32_t spirv::InterfaceVarABIAttr::getDescriptorSet() {
-  return getImpl()->descriptorSet.cast<IntegerAttr>().getInt();
+  return llvm::cast<IntegerAttr>(getImpl()->descriptorSet).getInt();
 }
 
 std::optional<spirv::StorageClass>
 spirv::InterfaceVarABIAttr::getStorageClass() {
   if (getImpl()->storageClass)
     return static_cast<spirv::StorageClass>(
-        getImpl()->storageClass.cast<IntegerAttr>().getValue().getZExtValue());
+        llvm::cast<IntegerAttr>(getImpl()->storageClass)
+            .getValue()
+            .getZExtValue());
   return std::nullopt;
 }
 
 LogicalResult spirv::InterfaceVarABIAttr::verify(
     function_ref<InFlightDiagnostic()> emitError, IntegerAttr descriptorSet,
     IntegerAttr binding, IntegerAttr storageClass) {
   if (!descriptorSet.getType().isSignlessInteger(32))
     return emitError() << "expected 32-bit integer for descriptor set";
 
   if (!binding.getType().isSignlessInteger(32))
     return emitError() << "expected 32-bit integer for binding";
 
   if (storageClass) {
-    if (auto storageClassAttr = storageClass.cast<IntegerAttr>()) {
+    if (auto storageClassAttr = llvm::cast<IntegerAttr>(storageClass)) {
       auto storageClassValue =
           spirv::symbolizeStorageClass(storageClassAttr.getInt());
       if (!storageClassValue)
         return emitError() << "unknown storage class";
     } else {
       return emitError() << "expected valid storage class";
     }
   }
spirv::VerCapExtAttr spirv::VerCapExtAttr::get(IntegerAttr version,
   MLIRContext *context = version.getContext();
   return Base::get(context, version, capabilities, extensions);
 }
 
 StringRef spirv::VerCapExtAttr::getKindName() { return "vce"; }
 
 spirv::Version spirv::VerCapExtAttr::getVersion() {
   return static_cast<spirv::Version>(
-      getImpl()->version.cast<IntegerAttr>().getValue().getZExtValue());
+      llvm::cast<IntegerAttr>(getImpl()->version).getValue().getZExtValue());
 }
 
 spirv::VerCapExtAttr::ext_iterator::ext_iterator(ArrayAttr::iterator it)
     : llvm::mapped_iterator<ArrayAttr::iterator,
                             spirv::Extension (*)(Attribute)>(
           it, [](Attribute attr) {
-            return *symbolizeExtension(attr.cast<StringAttr>().getValue());
+            return *symbolizeExtension(llvm::cast<StringAttr>(attr).getValue());
           }) {}
 
 spirv::VerCapExtAttr::ext_range spirv::VerCapExtAttr::getExtensions() {
   auto range = getExtensionsAttr().getValue();
   return {ext_iterator(range.begin()), ext_iterator(range.end())};
 }
 
 ArrayAttr spirv::VerCapExtAttr::getExtensionsAttr() {
-  return getImpl()->extensions.cast<ArrayAttr>();
+  return llvm::cast<ArrayAttr>(getImpl()->extensions);
 }
 
 spirv::VerCapExtAttr::cap_iterator::cap_iterator(ArrayAttr::iterator it)
     : llvm::mapped_iterator<ArrayAttr::iterator,
                             spirv::Capability (*)(Attribute)>(
           it, [](Attribute attr) {
             return *symbolizeCapability(
-                attr.cast<IntegerAttr>().getValue().getZExtValue());
+                llvm::cast<IntegerAttr>(attr).getValue().getZExtValue());
           }) {}
 
 spirv::VerCapExtAttr::cap_range spirv::VerCapExtAttr::getCapabilities() {
   auto range = getCapabilitiesAttr().getValue();
   return {cap_iterator(range.begin()), cap_iterator(range.end())};
 }
 
 ArrayAttr spirv::VerCapExtAttr::getCapabilitiesAttr() {
-  return getImpl()->capabilities.cast<ArrayAttr>();
+  return llvm::cast<ArrayAttr>(getImpl()->capabilities);
 }
 
 LogicalResult
 spirv::VerCapExtAttr::verify(function_ref<InFlightDiagnostic()> emitError,
                              IntegerAttr version, ArrayAttr capabilities,
                              ArrayAttr extensions) {
   if (!version.getType().isSignlessInteger(32))
     return emitError() << "expected 32-bit integer for version";
 
   if (!llvm::all_of(capabilities.getValue(), [](Attribute attr) {
-        if (auto intAttr = attr.dyn_cast<IntegerAttr>())
+        if (auto intAttr = llvm::dyn_cast<IntegerAttr>(attr))
           if (spirv::symbolizeCapability(intAttr.getValue().getZExtValue()))
             return true;
         return false;
       }))
     return emitError() << "unknown capability in capability list";
 
   if (!llvm::all_of(extensions.getValue(), [](Attribute attr) {
-        if (auto strAttr = attr.dyn_cast<StringAttr>())
+        if (auto strAttr = llvm::dyn_cast<StringAttr>(attr))
           if (spirv::symbolizeExtension(strAttr.getValue()))
             return true;
         return false;
       }))
     return emitError() << "unknown extension in extension list";
 
   return success();
 }
spirv::TargetEnvAttr spirv::TargetEnvAttr::get(
   MLIRContext *context = triple.getContext();
   return Base::get(context, triple, clientAPI, vendorID, deviceType, deviceID,
                    limits);
 }
 
 StringRef spirv::TargetEnvAttr::getKindName() { return "target_env"; }
 
 spirv::VerCapExtAttr spirv::TargetEnvAttr::getTripleAttr() const {
-  return getImpl()->triple.cast<spirv::VerCapExtAttr>();
+  return llvm::cast<spirv::VerCapExtAttr>(getImpl()->triple);
 }
 
 spirv::Version spirv::TargetEnvAttr::getVersion() const {
   return getTripleAttr().getVersion();
 }
 
 spirv::VerCapExtAttr::ext_range spirv::TargetEnvAttr::getExtensions() {
   return getTripleAttr().getExtensions();
spirv::DeviceType spirv::TargetEnvAttr::getDeviceType() const {
   return getImpl()->deviceType;
 }
 
 uint32_t spirv::TargetEnvAttr::getDeviceID() const {
   return getImpl()->deviceID;
 }
 
 spirv::ResourceLimitsAttr spirv::TargetEnvAttr::getResourceLimits() const {
-  return getImpl()->limits.cast<spirv::ResourceLimitsAttr>();
+  return llvm::cast<spirv::ResourceLimitsAttr>(getImpl()->limits);
 }
 
 //===----------------------------------------------------------------------===//
 // ODS Generated Attributes
 //===----------------------------------------------------------------------===//
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.cpp.inc"
static void print(spirv::VerCapExtAttr triple, DialectAsmPrinter &printer) {
   auto &os = printer.getStream();
   printer << spirv::VerCapExtAttr::getKindName() << "<"
           << spirv::stringifyVersion(triple.getVersion()) << ", [";
   llvm::interleaveComma(
       triple.getCapabilities(), os,
       [&](spirv::Capability cap) { os << spirv::stringifyCapability(cap); });
   printer << "], [";
   llvm::interleaveComma(triple.getExtensionsAttr(), os, [&](Attribute attr) {
-    os << attr.cast<StringAttr>().getValue();
+    os << llvm::cast<StringAttr>(attr).getValue();
   });
   printer << "]>";
 }
 
 static void print(spirv::TargetEnvAttr targetEnv, DialectAsmPrinter &printer) {
   printer << spirv::TargetEnvAttr::getKindName() << "<#spirv.";
   print(targetEnv.getTripleAttr(), printer);
   auto clientAPI = targetEnv.getClientAPI();
static void print(spirv::InterfaceVarABIAttr interfaceVarABIAttr,
   printer << ">";
 }
 
 void SPIRVDialect::printAttribute(Attribute attr,
                                   DialectAsmPrinter &printer) const {
   if (succeeded(generatedAttributePrinter(attr, printer)))
     return;
 
-  if (auto targetEnv = attr.dyn_cast<TargetEnvAttr>())
+  if (auto targetEnv = llvm::dyn_cast<TargetEnvAttr>(attr))
     print(targetEnv, printer);
-  else if (auto vceAttr = attr.dyn_cast<VerCapExtAttr>())
+  else if (auto vceAttr = llvm::dyn_cast<VerCapExtAttr>(attr))
     print(vceAttr, printer);
-  else if (auto interfaceVarABIAttr = attr.dyn_cast<InterfaceVarABIAttr>())
+  else if (auto interfaceVarABIAttr = llvm::dyn_cast<InterfaceVarABIAttr>(attr))
     print(interfaceVarABIAttr, printer);
   else
     llvm_unreachable("unhandled SPIR-V attribute kind");
 }
 
 //===----------------------------------------------------------------------===//
 // SPIR-V Dialect
 //===----------------------------------------------------------------------===//
 
 void spirv::SPIRVDialect::registerAttributes() {
   addAttributes<InterfaceVarABIAttr, TargetEnvAttr, VerCapExtAttr>();
   addAttributes<
 #define GET_ATTRDEF_LIST
 #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.cpp.inc"
       >();
 }

mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp

 //===----------------------------------------------------------------------===//
 
 /// Returns the boolean value under the hood if the given `boolAttr` is a scalar
 /// or splat vector bool constant.
 static std::optional<bool> getScalarOrSplatBoolAttr(Attribute attr) {
   if (!attr)
     return std::nullopt;
 
-  if (auto boolAttr = attr.dyn_cast<BoolAttr>())
+  if (auto boolAttr = llvm::dyn_cast<BoolAttr>(attr))
     return boolAttr.getValue();
-  if (auto splatAttr = attr.dyn_cast<SplatElementsAttr>())
+  if (auto splatAttr = llvm::dyn_cast<SplatElementsAttr>(attr))
     if (splatAttr.getElementType().isInteger(1))
       return splatAttr.getSplatValue<bool>();
   return std::nullopt;
 }
 
 // Extracts an element from the given `composite` by following the given
 // `indices`. Returns a null Attribute if error happens.
 static Attribute extractCompositeElement(Attribute composite,
                                          ArrayRef<unsigned> indices) {
   // Check that given composite is a constant.
   if (!composite)
     return {};
   // Return composite itself if we reach the end of the index chain.
   if (indices.empty())
     return composite;
 
-  if (auto vector = composite.dyn_cast<ElementsAttr>()) {
+  if (auto vector = llvm::dyn_cast<ElementsAttr>(composite)) {
     assert(indices.size() == 1 && "must have exactly one index for a vector");
     return vector.getValues<Attribute>()[indices[0]];
   }
 
-  if (auto array = composite.dyn_cast<ArrayAttr>()) {
+  if (auto array = llvm::dyn_cast<ArrayAttr>(composite)) {
     assert(!indices.empty() && "must have at least one index for an array");
     return extractCompositeElement(array.getValue()[indices[0]],
                                    indices.drop_front());
   }
 
   return {};
 }
 
OpFoldResult spirv::CompositeExtractOp::fold(FoldAdaptor adaptor) {
   if (auto insertOp =
           getComposite().getDefiningOp<spirv::CompositeInsertOp>()) {
     if (getIndices() == insertOp.getIndices())
       return insertOp.getObject();
   }
 
   if (auto constructOp =
           getComposite().getDefiningOp<spirv::CompositeConstructOp>()) {
-    auto type = constructOp.getType().cast<spirv::CompositeType>();
+    auto type = llvm::cast<spirv::CompositeType>(constructOp.getType());
     if (getIndices().size() == 1 &&
         constructOp.getConstituents().size() == type.getNumElements()) {
       auto i = getIndices().begin()->cast<IntegerAttr>();
       return constructOp.getConstituents()[i.getValue().getSExtValue()];
     }
   }
 
   auto indexVector =
       llvm::to_vector<8>(llvm::map_range(getIndices(), [](Attribute attr) {
-        return static_cast<unsigned>(attr.cast<IntegerAttr>().getInt());
+        return static_cast<unsigned>(llvm::cast<IntegerAttr>(attr).getInt());
       }));
   return extractCompositeElement(adaptor.getComposite(), indexVector);
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.Constant
 //===----------------------------------------------------------------------===//
 
if (!trueBrStoreOp || !trueBrBranchOp || !falseBrStoreOp ||
     return failure();
   }
 
   // Checks that given type is valid for `spirv.SelectOp`.
   // According to SPIR-V spec:
   // "Before version 1.4, Result Type must be a pointer, scalar, or vector.
   // Starting with version 1.4, Result Type can additionally be a composite type
   // other than a vector."
-  bool isScalarOrVector = trueBrStoreOp.getValue()
-                              .getType()
-                              .cast<spirv::SPIRVType>()
-                              .isScalarOrVector();
+  bool isScalarOrVector =
+      llvm::cast<spirv::SPIRVType>(trueBrStoreOp.getValue().getType())
 
   // Check that each `spirv.Store` uses the same pointer, memory access
   // attributes and a valid type of the value.
   if ((trueBrStoreOp.getPtr() != falseBrStoreOp.getPtr()) ||
       !isSameAttrList(trueBrStoreOp, falseBrStoreOp) || !isScalarOrVector) {
     return failure();
   }
 

mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp

static Type parseAndVerifyType(SPIRVDialect const &dialect,
   if (parser.parseType(type))
     return Type();
 
   // Allow SPIR-V dialect types
   if (&type.getDialect() == &dialect)
     return type;
 
   // Check other allowed types
-  if (auto t = type.dyn_cast<FloatType>()) {
+  if (auto t = llvm::dyn_cast<FloatType>(type)) {
     if (type.isBF16()) {
       parser.emitError(typeLoc, "cannot use 'bf16' to compose SPIR-V types");
       return Type();
     }
-  } else if (auto t = type.dyn_cast<IntegerType>()) {
+  } else if (auto t = llvm::dyn_cast<IntegerType>(type)) {
     if (!ScalarType::isValid(t)) {
       parser.emitError(typeLoc,
                        "only 1/8/16/32/64-bit integer type allowed but found ")
           << type;
       return Type();
     }
-  } else if (auto t = type.dyn_cast<VectorType>()) {
+  } else if (auto t = llvm::dyn_cast<VectorType>(type)) {
     if (t.getRank() != 1) {
       parser.emitError(typeLoc, "only 1-D vector allowed but found ") << t;
       return Type();
     }
     if (t.getNumElements() > 4) {
       parser.emitError(
           typeLoc, "vector length has to be less than or equal to 4 but found ")
           << t.getNumElements();

 
 static Type parseAndVerifyMatrixType(SPIRVDialect const &dialect,
                                      DialectAsmParser &parser) {
   Type type;
   SMLoc typeLoc = parser.getCurrentLocation();
   if (parser.parseType(type))
     return Type();
 
-  if (auto t = type.dyn_cast<VectorType>()) {
+  if (auto t = llvm::dyn_cast<VectorType>(type)) {
     if (t.getRank() != 1) {
       parser.emitError(typeLoc, "only 1-D vector allowed but found ") << t;
       return Type();
     }
     if (t.getNumElements() > 4 || t.getNumElements() < 2) {
       parser.emitError(typeLoc,
                        "matrix columns size has to be less than or equal "
                        "to 4 and greater than or equal 2, but found ")
           << t.getNumElements();
       return Type();
     }
 
-    if (!t.getElementType().isa<FloatType>()) {
+    if (!llvm::isa<FloatType>(t.getElementType())) {
       parser.emitError(typeLoc, "matrix columns' elements must be of "
                                 "Float type, got ")
           << t.getElementType();
       return Type();
     }
   } else {
     parser.emitError(typeLoc, "matrix must be composed using vector "
                               "type, got ")
         << type;
     return Type();
   }
 
   return type;
 }
 
 static Type parseAndVerifySampledImageType(SPIRVDialect const &dialect,
                                            DialectAsmParser &parser) {
   Type type;
   SMLoc typeLoc = parser.getCurrentLocation();
   if (parser.parseType(type))
     return Type();
 
-  if (!type.isa<ImageType>()) {
+  if (!llvm::isa<ImageType>(type)) {
     parser.emitError(typeLoc,
                      "sampled image must be composed using image type, got ")
         << type;
     return Type();
   }
 
   return type;
 }

 //===----------------------------------------------------------------------===//
 
 LogicalResult SPIRVDialect::verifyOperationAttribute(Operation *op,
                                                      NamedAttribute attribute) {
   StringRef symbol = attribute.getName().strref();
   Attribute attr = attribute.getValue();
 
   if (symbol == spirv::getEntryPointABIAttrName()) {
-    if (!attr.isa<spirv::EntryPointABIAttr>()) {
+    if (!llvm::isa<spirv::EntryPointABIAttr>(attr)) {
       return op->emitError("'")
              << symbol << "' attribute must be an entry point ABI attribute";
     }
   } else if (symbol == spirv::getTargetEnvAttrName()) {
-    if (!attr.isa<spirv::TargetEnvAttr>())
+    if (!llvm::isa<spirv::TargetEnvAttr>(attr))
       return op->emitError("'") << symbol << "' must be a spirv::TargetEnvAttr";
   } else {
     return op->emitError("found unsupported '")
            << symbol << "' attribute on operation";
   }
 
   return success();
 }
 
 /// Verifies the given SPIR-V `attribute` attached to a value of the given
 /// `valueType` is valid.
 static LogicalResult verifyRegionAttribute(Location loc, Type valueType,
                                            NamedAttribute attribute) {
   StringRef symbol = attribute.getName().strref();
   Attribute attr = attribute.getValue();
 
   if (symbol != spirv::getInterfaceVarABIAttrName())
     return emitError(loc, "found unsupported '")
            << symbol << "' attribute on region argument";
 
-  auto varABIAttr = attr.dyn_cast<spirv::InterfaceVarABIAttr>();
+  auto varABIAttr = llvm::dyn_cast<spirv::InterfaceVarABIAttr>(attr);
   if (!varABIAttr)
     return emitError(loc, "'")
            << symbol << "' must be a spirv::InterfaceVarABIAttr";
 
   if (varABIAttr.getStorageClass() && !valueType.isIntOrIndexOrFloat())
     return emitError(loc, "'") << symbol
                                << "' attribute cannot specify storage class "
                                   "when attaching to a non-scalar value";

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

static ParseResult parseOneResultSameOperandTypeOp(OpAsmParser &parser,
   // If the operand list is in-between parentheses, then we have a generic form.
   // (see the fallback in `printOneResultOp`).
   SMLoc loc = parser.getCurrentLocation();
   if (!parser.parseOptionalLParen()) {
     if (parser.parseOperandList(ops) || parser.parseRParen() ||
         parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColon() || parser.parseType(type))
       return failure();
-    auto fnType = type.dyn_cast<FunctionType>();
+    auto fnType = llvm::dyn_cast<FunctionType>(type);
     if (!fnType) {
       parser.emitError(loc, "expected function type");
       return failure();
     }
     if (parser.resolveOperands(ops, fnType.getInputs(), loc, result.operands))
       return failure();
     result.addTypes(fnType.getResults());
     return success();

 }
 
 static LogicalResult extractValueFromConstOp(Operation *op, int32_t &value) {
   auto constOp = dyn_cast_or_null<spirv::ConstantOp>(op);
   if (!constOp) {
     return failure();
   }
   auto valueAttr = constOp.getValue();
-  auto integerValueAttr = valueAttr.dyn_cast<IntegerAttr>();
+  auto integerValueAttr = llvm::dyn_cast<IntegerAttr>(valueAttr);
   if (!integerValueAttr) {
     return failure();
   }
 
   if (integerValueAttr.getType().isSignlessInteger())
     value = integerValueAttr.getInt();
   else
     value = integerValueAttr.getSInt();

 parseEnumStrAttr(EnumClass &value, OpAsmParser &parser,
                  StringRef attrName = spirv::attributeName<EnumClass>()) {
   Attribute attrVal;
   NamedAttrList attr;
   auto loc = parser.getCurrentLocation();
   if (parser.parseAttribute(attrVal, parser.getBuilder().getNoneType(),
                             attrName, attr))
     return failure();
-  if (!attrVal.isa<StringAttr>())
+  if (!llvm::isa<StringAttr>(attrVal))
     return parser.emitError(loc, "expected ")
            << attrName << " attribute specified as string";
-  auto attrOptional =
-      spirv::symbolizeEnum<EnumClass>(attrVal.cast<StringAttr>().getValue());
+  auto attrOptional = spirv::symbolizeEnum<EnumClass>(
+      llvm::cast<StringAttr>(attrVal).getValue());
   if (!attrOptional)
     return parser.emitError(loc, "invalid ")
            << attrName << " attribute specification: " << attrVal;
   value = *attrOptional;
   return success();
 }
 
 /// Parses the next string attribute in `parser` as an enumerant of the given
static LogicalResult verifyCastOp(Operation *op,
   // Some CastOps have no limit on bit widths for result and operand type.
   if (skipBitWidthCheck)
     return success();
 
   Type operandType = op->getOperand(0).getType();
   Type resultType = op->getResult(0).getType();
 
   // ODS checks that result type and operand type have the same shape.
-  if (auto vectorType = operandType.dyn_cast<VectorType>()) {
+  if (auto vectorType = llvm::dyn_cast<VectorType>(operandType)) {
     operandType = vectorType.getElementType();
-    resultType = resultType.cast<VectorType>().getElementType();
+    resultType = llvm::cast<VectorType>(resultType).getElementType();
   }
 
   if (auto coopMatrixType =
-          operandType.dyn_cast<spirv::CooperativeMatrixNVType>()) {
+          llvm::dyn_cast<spirv::CooperativeMatrixNVType>(operandType)) {
     operandType = coopMatrixType.getElementType();
     resultType =
-        resultType.cast<spirv::CooperativeMatrixNVType>().getElementType();
+        llvm::cast<spirv::CooperativeMatrixNVType>(resultType).getElementType();
   }
 
   if (auto jointMatrixType =
-          operandType.dyn_cast<spirv::JointMatrixINTELType>()) {
+          llvm::dyn_cast<spirv::JointMatrixINTELType>(operandType)) {
     operandType = jointMatrixType.getElementType();
     resultType =
-        resultType.cast<spirv::JointMatrixINTELType>().getElementType();
+        llvm::cast<spirv::JointMatrixINTELType>(resultType).getElementType();
   }
 
   auto operandTypeBitWidth = operandType.getIntOrFloatBitWidth();
   auto resultTypeBitWidth = resultType.getIntOrFloatBitWidth();
   auto isSameBitWidth = operandTypeBitWidth == resultTypeBitWidth;
 
   if (requireSameBitWidth) {
     if (!isSameBitWidth) {
if (!memAccessAttr) {
     if (op->getAttr(kAlignmentAttrName)) {
       return memoryOp.emitOpError(
           "invalid alignment specification without aligned memory access "
           "specification");
     }
     return success();
   }
 
-  auto memAccess = memAccessAttr.template cast<spirv::MemoryAccessAttr>();
+  auto memAccess = llvm::cast<spirv::MemoryAccessAttr>(memAccessAttr);
 
   if (!memAccess) {
     return memoryOp.emitOpError("invalid memory access specifier: ")
            << memAccessAttr;
   }
 
   if (spirv::bitEnumContainsAll(memAccess.getValue(),
                                 spirv::MemoryAccess::Aligned)) {
if (!memAccessAttr) {
     if (op->getAttr(kSourceAlignmentAttrName)) {
       return memoryOp.emitOpError(
           "invalid alignment specification without aligned memory access "
           "specification");
     }
     return success();
   }
 
-  auto memAccess = memAccessAttr.template cast<spirv::MemoryAccessAttr>();
+  auto memAccess = llvm::cast<spirv::MemoryAccessAttr>(memAccessAttr);
 
   if (!memAccess) {
     return memoryOp.emitOpError("invalid memory access specifier: ")
            << memAccess;
   }
 
   if (spirv::bitEnumContainsAll(memAccess.getValue(),
                                 spirv::MemoryAccess::Aligned)) {

 static LogicalResult verifyLoadStorePtrAndValTypes(LoadStoreOpTy op, Value ptr,
                                                    Value val) {
   // ODS already checks ptr is spirv::PointerType. Just check that the pointee
   // type of the pointer and the type of the value are the same
   //
   // TODO: Check that the value type satisfies restrictions of
   // SPIR-V OpLoad/OpStore operations
   if (val.getType() !=
-      ptr.getType().cast<spirv::PointerType>().getPointeeType()) {
+      llvm::cast<spirv::PointerType>(ptr.getType()).getPointeeType()) {
     return op.emitOpError("mismatch in result type and pointer type");
   }
   return success();
 }
 
 template <typename BlockReadWriteOpTy>
 static LogicalResult verifyBlockReadWritePtrAndValTypes(BlockReadWriteOpTy op,
                                                         Value ptr, Value val) {
   auto valType = val.getType();
-  if (auto valVecTy = valType.dyn_cast<VectorType>())
+  if (auto valVecTy = llvm::dyn_cast<VectorType>(valType))
     valType = valVecTy.getElementType();
 
-  if (valType != ptr.getType().cast<spirv::PointerType>().getPointeeType()) {
+  if (valType !=
+      llvm::cast<spirv::PointerType>(ptr.getType()).getPointeeType()) {
     return op.emitOpError("mismatch in result type and pointer type");
   }
   return success();
 }
 
 static ParseResult parseVariableDecorations(OpAsmParser &parser,
                                             OperationState &state) {
   auto builtInName = llvm::convertToSnakeFromCamelCase(
if (auto builtin = op->getAttrOfType<StringAttr>(builtInName)) {
     elidedAttrs.push_back(builtInName);
   }
 
   printer.printOptionalAttrDict(op->getAttrs(), elidedAttrs);
 }
 
 // Get bit width of types.
 static unsigned getBitWidth(Type type) {
-  if (type.isa<spirv::PointerType>()) {
+  if (llvm::isa<spirv::PointerType>(type)) {
     // Just return 64 bits for pointer types for now.
     // TODO: Make sure not caller relies on the actual pointer width value.
     return 64;
   }
 
   if (type.isIntOrFloat())
     return type.getIntOrFloatBitWidth();
 
-  if (auto vectorType = type.dyn_cast<VectorType>()) {
+  if (auto vectorType = llvm::dyn_cast<VectorType>(type)) {
     assert(vectorType.getElementType().isIntOrFloat());
     return vectorType.getNumElements() *
            vectorType.getElementType().getIntOrFloatBitWidth();
   }
   llvm_unreachable("unhandled bit width computation for type");
 }
 
 /// Walks the given type hierarchy with the given indices, potentially down
 /// to component granularity, to select an element type. Returns null type and
 /// emits errors with the given loc on failure.
 static Type
 getElementType(Type type, ArrayRef<int32_t> indices,
                function_ref<InFlightDiagnostic(StringRef)> emitErrorFn) {
   if (indices.empty()) {
     emitErrorFn("expected at least one index for spirv.CompositeExtract");
     return nullptr;
   }
 
   for (auto index : indices) {
-    if (auto cType = type.dyn_cast<spirv::CompositeType>()) {
+    if (auto cType = llvm::dyn_cast<spirv::CompositeType>(type)) {
       if (cType.hasCompileTimeKnownNumElements() &&
           (index < 0 ||
            static_cast<uint64_t>(index) >= cType.getNumElements())) {
         emitErrorFn("index ") << index << " out of bounds for " << type;
         return nullptr;
       }
       type = cType.getElementType(index);
     } else {
       emitErrorFn("cannot extract from non-composite type ")
           << type << " with index " << index;
       return nullptr;
     }
   }
   return type;
 }
 
 static Type
 getElementType(Type type, Attribute indices,
                function_ref<InFlightDiagnostic(StringRef)> emitErrorFn) {
-  auto indicesArrayAttr = indices.dyn_cast<ArrayAttr>();
+  auto indicesArrayAttr = llvm::dyn_cast<ArrayAttr>(indices);
   if (!indicesArrayAttr) {
     emitErrorFn("expected a 32-bit integer array attribute for 'indices'");
     return nullptr;
   }
   if (indicesArrayAttr.empty()) {
     emitErrorFn("expected at least one index for spirv.CompositeExtract");
     return nullptr;
   }
 
   SmallVector<int32_t, 2> indexVals;
   for (auto indexAttr : indicesArrayAttr) {
-    auto indexIntAttr = indexAttr.dyn_cast<IntegerAttr>();
+    auto indexIntAttr = llvm::dyn_cast<IntegerAttr>(indexAttr);
     if (!indexIntAttr) {
       emitErrorFn("expected an 32-bit integer for index, but found '")
           << indexAttr << "'";
       return nullptr;
     }
     indexVals.push_back(indexIntAttr.getInt());
   }
   return getElementType(type, indexVals, emitErrorFn);

 /// Returns true if the given `block` only contains one `spirv.mlir.merge` op.
 static inline bool isMergeBlock(Block &block) {
   return !block.empty() && std::next(block.begin()) == block.end() &&
          isa<spirv::MergeOp>(block.front());
 }
 
 template <typename ExtendedBinaryOp>
 static LogicalResult verifyArithmeticExtendedBinaryOp(ExtendedBinaryOp op) {
-  auto resultType = op.getType().template cast<spirv::StructType>();
+  auto resultType = llvm::cast<spirv::StructType>(op.getType());
   if (resultType.getNumElements() != 2)
     return op.emitOpError("expected result struct type containing two members");
 
   if (!llvm::all_equal({op.getOperand1().getType(), op.getOperand2().getType(),
                         resultType.getElementType(0),
                         resultType.getElementType(1)}))
     return op.emitOpError(
         "expected all operand types and struct member types are the same");
 
   return success();
 }
 
 static ParseResult parseArithmeticExtendedBinaryOp(OpAsmParser &parser,
                                                    OperationState &result) {
   SmallVector<OpAsmParser::UnresolvedOperand, 2> operands;
   if (parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseOperandList(operands) || parser.parseColon())
     return failure();
 
   Type resultType;
   SMLoc loc = parser.getCurrentLocation();
   if (parser.parseType(resultType))
     return failure();
 
-  auto structType = resultType.dyn_cast<spirv::StructType>();
+  auto structType = llvm::dyn_cast<spirv::StructType>(resultType);
   if (!structType || structType.getNumElements() != 2)
     return parser.emitError(loc, "expected spirv.struct type with two members");
 
   SmallVector<Type, 2> operandTypes(2, structType.getElementType(0));
   if (parser.resolveOperands(operands, operandTypes, loc, result.operands))
     return failure();
 
   result.addTypes(resultType);
static ParseResult parseAtomicUpdateOp(OpAsmParser &parser,
   if (parseEnumStrAttr<spirv::ScopeAttr>(scope, parser, state,
                                          kMemoryScopeAttrName) ||
       parseEnumStrAttr<spirv::MemorySemanticsAttr>(memoryScope, parser, state,
                                                    kSemanticsAttrName) ||
       parser.parseOperandList(operandInfo, (hasValue ? 2 : 1)) ||
       parser.getCurrentLocation(&loc) || parser.parseColonType(type))
     return failure();
 
-  auto ptrType = type.dyn_cast<spirv::PointerType>();
+  auto ptrType = llvm::dyn_cast<spirv::PointerType>(type);
   if (!ptrType)
     return parser.emitError(loc, "expected pointer type");
 
   SmallVector<Type, 2> operandTypes;
   operandTypes.push_back(ptrType);
   if (hasValue)
     operandTypes.push_back(ptrType.getPointeeType());
   if (parser.resolveOperands(operandInfo, operandTypes, parser.getNameLoc(),

 template <>
 StringRef stringifyTypeName<FloatType>() {
   return "float";
 }
 
 // Verifies an atomic update op.
 template <typename ExpectedElementType>
 static LogicalResult verifyAtomicUpdateOp(Operation *op) {
-  auto ptrType = op->getOperand(0).getType().cast<spirv::PointerType>();
+  auto ptrType = llvm::cast<spirv::PointerType>(op->getOperand(0).getType());
   auto elementType = ptrType.getPointeeType();
-  if (!elementType.isa<ExpectedElementType>())
+  if (!llvm::isa<ExpectedElementType>(elementType))
     return op->emitOpError() << "pointer operand must point to an "
                              << stringifyTypeName<ExpectedElementType>()
                              << " value, found " << elementType;
 
   if (op->getNumOperands() > 1) {
     auto valueType = op->getOperand(1).getType();
     if (valueType != elementType)
       return op->emitOpError("expected value to have the same type as the "
static LogicalResult verifyGroupNonUniformArithmeticOp(Operation *groupOp) {
   }
   return success();
 }
 
 /// Result of a logical op must be a scalar or vector of boolean type.
 static Type getUnaryOpResultType(Type operandType) {
   Builder builder(operandType.getContext());
   Type resultType = builder.getIntegerType(1);
-  if (auto vecType = operandType.dyn_cast<VectorType>())
+  if (auto vecType = llvm::dyn_cast<VectorType>(operandType))
     return VectorType::get(vecType.getNumElements(), resultType);
   return resultType;
 }
 
 static LogicalResult verifyShiftOp(Operation *op) {
   if (op->getOperand(0).getType() != op->getResult(0).getType()) {
     return op->emitError("expected the same type for the first operand and "
                          "result, but provided ")
            << op->getOperand(0).getType() << " and "
            << op->getResult(0).getType();
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.AccessChainOp
 //===----------------------------------------------------------------------===//
 
 static Type getElementPtrType(Type type, ValueRange indices, Location baseLoc) {
-  auto ptrType = type.dyn_cast<spirv::PointerType>();
+  auto ptrType = llvm::dyn_cast<spirv::PointerType>(type);
   if (!ptrType) {
     emitError(baseLoc, "'spirv.AccessChain' op expected a pointer "
                        "to composite type, but provided ")
         << type;
     return nullptr;
   }
 
   auto resultType = ptrType.getPointeeType();
   auto resultStorageClass = ptrType.getStorageClass();
   int32_t index = 0;
 
   for (auto indexSSA : indices) {
-    auto cType = resultType.dyn_cast<spirv::CompositeType>();
+    auto cType = llvm::dyn_cast<spirv::CompositeType>(resultType);
     if (!cType) {
       emitError(
           baseLoc,
           "'spirv.AccessChain' op cannot extract from non-composite type ")
           << resultType << " with index " << index;
       return nullptr;
     }
     index = 0;
-    if (resultType.isa<spirv::StructType>()) {
+    if (llvm::isa<spirv::StructType>(resultType)) {
       Operation *op = indexSSA.getDefiningOp();
       if (!op) {
         emitError(baseLoc, "'spirv.AccessChain' op index must be an "
                            "integer spirv.Constant to access "
                            "element of spirv.struct");
         return nullptr;
       }
 

 template <typename Op>
 static LogicalResult verifyAccessChain(Op accessChainOp, ValueRange indices) {
   auto resultType = getElementPtrType(accessChainOp.getBasePtr().getType(),
                                       indices, accessChainOp.getLoc());
   if (!resultType)
     return failure();
 
   auto providedResultType =
-      accessChainOp.getType().template dyn_cast<spirv::PointerType>();
+      llvm::dyn_cast<spirv::PointerType>(accessChainOp.getType());
   if (!providedResultType)
     return accessChainOp.emitOpError(
                "result type must be a pointer, but provided")
            << providedResultType;
 
   if (resultType != providedResultType)
     return accessChainOp.emitOpError("invalid result type: expected ")
            << resultType << ", but provided " << providedResultType;
if (parseEnumStrAttr<spirv::ScopeAttr>(memoryScope, parser, state,
           unequalSemantics, parser, state, kUnequalSemanticsAttrName) ||
       parser.parseOperandList(operandInfo, 3))
     return failure();
 
   auto loc = parser.getCurrentLocation();
   if (parser.parseColonType(type))
     return failure();
 
-  auto ptrType = type.dyn_cast<spirv::PointerType>();
+  auto ptrType = llvm::dyn_cast<spirv::PointerType>(type);
   if (!ptrType)
     return parser.emitError(loc, "expected pointer type");
 
   if (parser.resolveOperands(
           operandInfo,
           {ptrType, ptrType.getPointeeType(), ptrType.getPointeeType()},
           parser.getNameLoc(), state.operands))
     return failure();
return atomOp.emitOpError("value operand must have the same type as the op "
            << atomOp.getValue().getType() << " vs " << atomOp.getType();
 
   if (atomOp.getType() != atomOp.getComparator().getType())
     return atomOp.emitOpError(
                "comparator operand must have the same type as the op "
                "result, but found ")
            << atomOp.getComparator().getType() << " vs " << atomOp.getType();
 
-  Type pointeeType = atomOp.getPointer()
-                         .getType()
-                         .template cast<spirv::PointerType>()
-                         .getPointeeType();
+  Type pointeeType =
+      llvm::cast<spirv::PointerType>(atomOp.getPointer().getType())
   if (atomOp.getType() != pointeeType)
     return atomOp.emitOpError(
                "pointer operand's pointee type must have the same "
                "as the op result type, but found ")
            << pointeeType << " vs " << atomOp.getType();
 
   // TODO: Unequal cannot be set to Release or Acquire and Release.
   // In addition, Unequal cannot be set to a stronger memory-order then Equal.
if (parseEnumStrAttr<spirv::ScopeAttr>(memoryScope, parser, result,
                                                    kSemanticsAttrName) ||
       parser.parseOperandList(operandInfo, 2))
     return failure();
 
   auto loc = parser.getCurrentLocation();
   if (parser.parseColonType(type))
     return failure();
 
-  auto ptrType = type.dyn_cast<spirv::PointerType>();
+  auto ptrType = llvm::dyn_cast<spirv::PointerType>(type);
   if (!ptrType)
     return parser.emitError(loc, "expected pointer type");
 
   if (parser.resolveOperands(operandInfo, {ptrType, ptrType.getPointeeType()},
                              parser.getNameLoc(), result.operands))
     return failure();
 
   return parser.addTypeToList(ptrType.getPointeeType(), result.types);
 }
 
 LogicalResult spirv::AtomicExchangeOp::verify() {
   if (getType() != getValue().getType())
     return emitOpError("value operand must have the same type as the op "
                        "result, but found ")
            << getValue().getType() << " vs " << getType();
 
   Type pointeeType =
-      getPointer().getType().cast<spirv::PointerType>().getPointeeType();
+      llvm::cast<spirv::PointerType>(getPointer().getType()).getPointeeType();
   if (getType() != pointeeType)
     return emitOpError("pointer operand's pointee type must have the same "
                        "as the op result type, but found ")
            << pointeeType << " vs " << getType();
 
   return success();
 }
 

 LogicalResult spirv::BitcastOp::verify() {
   // TODO: The SPIR-V spec validation rules are different for different
   // versions.
   auto operandType = getOperand().getType();
   auto resultType = getResult().getType();
   if (operandType == resultType) {
     return emitError("result type must be different from operand type");
   }
-  if (operandType.isa<spirv::PointerType>() &&
-      !resultType.isa<spirv::PointerType>()) {
+  if (llvm::isa<spirv::PointerType>(operandType) &&
+      !llvm::isa<spirv::PointerType>(resultType)) {
     return emitError(
         "unhandled bit cast conversion from pointer type to non-pointer type");
   }
-  if (!operandType.isa<spirv::PointerType>() &&
-      resultType.isa<spirv::PointerType>()) {
+  if (!llvm::isa<spirv::PointerType>(operandType) &&
+      llvm::isa<spirv::PointerType>(resultType)) {
     return emitError(
         "unhandled bit cast conversion from non-pointer type to pointer type");
   }
   auto operandBitWidth = getBitWidth(operandType);
   auto resultBitWidth = getBitWidth(resultType);
   if (operandBitWidth != resultBitWidth) {
     return emitOpError("mismatch in result type bitwidth ")
            << resultBitWidth << " and operand type bitwidth "
            << operandBitWidth;
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.PtrCastToGenericOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::PtrCastToGenericOp::verify() {
-  auto operandType = getPointer().getType().cast<spirv::PointerType>();
-  auto resultType = getResult().getType().cast<spirv::PointerType>();
+  auto operandType = llvm::cast<spirv::PointerType>(getPointer().getType());
+  auto resultType = llvm::cast<spirv::PointerType>(getResult().getType());
 
   spirv::StorageClass operandStorage = operandType.getStorageClass();
   if (operandStorage != spirv::StorageClass::Workgroup &&
       operandStorage != spirv::StorageClass::CrossWorkgroup &&
       operandStorage != spirv::StorageClass::Function)
     return emitError("pointer must point to the Workgroup, CrossWorkgroup"
                      ", or Function Storage Class");
 
LogicalResult spirv::PtrCastToGenericOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.GenericCastToPtrOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::GenericCastToPtrOp::verify() {
-  auto operandType = getPointer().getType().cast<spirv::PointerType>();
-  auto resultType = getResult().getType().cast<spirv::PointerType>();
+  auto operandType = llvm::cast<spirv::PointerType>(getPointer().getType());
+  auto resultType = llvm::cast<spirv::PointerType>(getResult().getType());
 
   spirv::StorageClass operandStorage = operandType.getStorageClass();
   if (operandStorage != spirv::StorageClass::Generic)
     return emitError("pointer type must be of storage class Generic");
 
   spirv::StorageClass resultStorage = resultType.getStorageClass();
   if (resultStorage != spirv::StorageClass::Workgroup &&
       resultStorage != spirv::StorageClass::CrossWorkgroup &&
LogicalResult spirv::GenericCastToPtrOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.GenericCastToPtrExplicitOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::GenericCastToPtrExplicitOp::verify() {
-  auto operandType = getPointer().getType().cast<spirv::PointerType>();
-  auto resultType = getResult().getType().cast<spirv::PointerType>();
+  auto operandType = llvm::cast<spirv::PointerType>(getPointer().getType());
+  auto resultType = llvm::cast<spirv::PointerType>(getResult().getType());
 
   spirv::StorageClass operandStorage = operandType.getStorageClass();
   if (operandStorage != spirv::StorageClass::Generic)
     return emitError("pointer type must be of storage class Generic");
 
   spirv::StorageClass resultStorage = resultType.getStorageClass();
   if (resultStorage != spirv::StorageClass::Workgroup &&
       resultStorage != spirv::StorageClass::CrossWorkgroup &&

 }
 
 void spirv::BranchConditionalOp::print(OpAsmPrinter &printer) {
   printer << ' ' << getCondition();
 
   if (auto weights = getBranchWeights()) {
     printer << " [";
     llvm::interleaveComma(weights->getValue(), printer, [&](Attribute a) {
-      printer << a.cast<IntegerAttr>().getInt();
+      printer << llvm::cast<IntegerAttr>(a).getInt();
     });
     printer << "]";
   }
 
   printer << ", ";
   printer.printSuccessorAndUseList(getTrueBlock(), getTrueBlockArguments());
   printer << ", ";
   printer.printSuccessorAndUseList(getFalseBlock(), getFalseBlockArguments());
 }
 
 LogicalResult spirv::BranchConditionalOp::verify() {
   if (auto weights = getBranchWeights()) {
     if (weights->getValue().size() != 2) {
       return emitOpError("must have exactly two branch weights");
     }
     if (llvm::all_of(*weights, [](Attribute attr) {
-          return attr.cast<IntegerAttr>().getValue().isZero();
+          return llvm::cast<IntegerAttr>(attr).getValue().isZero();
         }))
       return emitOpError("branch weights cannot both be zero");
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.CompositeConstruct
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::CompositeConstructOp::verify() {
-  auto cType = getType().cast<spirv::CompositeType>();
+  auto cType = llvm::cast<spirv::CompositeType>(getType());
   operand_range constituents = this->getConstituents();
 
-  if (auto coopType = cType.dyn_cast<spirv::CooperativeMatrixNVType>()) {
+  if (auto coopType = llvm::dyn_cast<spirv::CooperativeMatrixNVType>(cType)) {
     if (constituents.size() != 1)
       return emitOpError("has incorrect number of operands: expected ")
              << "1, but provided " << constituents.size();
     if (coopType.getElementType() != constituents.front().getType())
       return emitOpError("operand type mismatch: expected operand type ")
              << coopType.getElementType() << ", but provided "
              << constituents.front().getType();
     return success();
   }
 
-  if (auto jointType = cType.dyn_cast<spirv::JointMatrixINTELType>()) {
+  if (auto jointType = llvm::dyn_cast<spirv::JointMatrixINTELType>(cType)) {
     if (constituents.size() != 1)
       return emitOpError("has incorrect number of operands: expected ")
              << "1, but provided " << constituents.size();
     if (jointType.getElementType() != constituents.front().getType())
       return emitOpError("operand type mismatch: expected operand type ")
              << jointType.getElementType() << ", but provided "
              << constituents.front().getType();
     return success();
   }
 
   if (constituents.size() == cType.getNumElements()) {
     for (auto index : llvm::seq<uint32_t>(0, constituents.size())) {
       if (constituents[index].getType() != cType.getElementType(index)) {
         return emitOpError("operand type mismatch: expected operand type ")
                << cType.getElementType(index) << ", but provided "
                << constituents[index].getType();
       }
     }
     return success();
   }
 
   // If not constructing a cooperative matrix type, then we must be constructing
   // a vector type.
-  auto resultType = cType.dyn_cast<VectorType>();
+  auto resultType = llvm::dyn_cast<VectorType>(cType);
   if (!resultType)
     return emitOpError(
         "expected to return a vector or cooperative matrix when the number of "
         "constituents is less than what the result needs");
 
   SmallVector<unsigned> sizes;
   for (Value component : constituents) {
-    if (!component.getType().isa<VectorType>() &&
+    if (!llvm::isa<VectorType>(component.getType()) &&
         !component.getType().isIntOrFloat())
       return emitOpError("operand type mismatch: expected operand to have "
                          "a scalar or vector type, but provided ")
              << component.getType();
 
     Type elementType = component.getType();
-    if (auto vectorType = component.getType().dyn_cast<VectorType>()) {
+    if (auto vectorType = llvm::dyn_cast<VectorType>(component.getType())) {
       sizes.push_back(vectorType.getNumElements());
       elementType = vectorType.getElementType();
     } else {
       sizes.push_back(1);
     }
 
     if (elementType != resultType.getElementType())
       return emitOpError("operand element type mismatch: expected to be ")

 }
 
 void spirv::CompositeExtractOp::print(OpAsmPrinter &printer) {
   printer << ' ' << getComposite() << getIndices() << " : "
           << getComposite().getType();
 }
 
 LogicalResult spirv::CompositeExtractOp::verify() {
-  auto indicesArrayAttr = getIndices().dyn_cast<ArrayAttr>();
+  auto indicesArrayAttr = llvm::dyn_cast<ArrayAttr>(getIndices());
   auto resultType =
       getElementType(getComposite().getType(), indicesArrayAttr, getLoc());
   if (!resultType)
     return failure();
 
   if (resultType != getType()) {
     return emitOpError("invalid result type: expected ")
            << resultType << " but provided " << getType();
return failure(
       parser.parseColonType(objectType) ||
       parser.parseKeywordType("into", compositeType) ||
       parser.resolveOperands(operands, {objectType, compositeType}, loc,
                              result.operands) ||
       parser.addTypesToList(compositeType, result.types));
 }
 
 LogicalResult spirv::CompositeInsertOp::verify() {
-  auto indicesArrayAttr = getIndices().dyn_cast<ArrayAttr>();
+  auto indicesArrayAttr = llvm::dyn_cast<ArrayAttr>(getIndices());
   auto objectType =
       getElementType(getComposite().getType(), indicesArrayAttr, getLoc());
   if (!objectType)
     return failure();
 
   if (objectType != getObject().getType()) {
     return emitOpError("object operand type should be ")
            << objectType << ", but found " << getObject().getType();

 
 ParseResult spirv::ConstantOp::parse(OpAsmParser &parser,
                                      OperationState &result) {
   Attribute value;
   if (parser.parseAttribute(value, kValueAttrName, result.attributes))
     return failure();
 
   Type type = NoneType::get(parser.getContext());
-  if (auto typedAttr = value.dyn_cast<TypedAttr>())
+  if (auto typedAttr = llvm::dyn_cast<TypedAttr>(value))
     type = typedAttr.getType();
-  if (type.isa<NoneType, TensorType>()) {
+  if (llvm::isa<NoneType, TensorType>(type)) {
     if (parser.parseColonType(type))
       return failure();
   }
 
   return parser.addTypeToList(type, result.types);
 }
 
 void spirv::ConstantOp::print(OpAsmPrinter &printer) {
   printer << ' ' << getValue();
-  if (getType().isa<spirv::ArrayType>())
+  if (llvm::isa<spirv::ArrayType>(getType()))
     printer << " : " << getType();
 }
 
 static LogicalResult verifyConstantType(spirv::ConstantOp op, Attribute value,
                                         Type opType) {
-  if (value.isa<IntegerAttr, FloatAttr>()) {
-    auto valueType = value.cast<TypedAttr>().getType();
+  if (llvm::isa<IntegerAttr, FloatAttr>(value)) {
+    auto valueType = llvm::cast<TypedAttr>(value).getType();
     if (valueType != opType)
       return op.emitOpError("result type (")
              << opType << ") does not match value type (" << valueType << ")";
     return success();
   }
-  if (value.isa<DenseIntOrFPElementsAttr, SparseElementsAttr>()) {
-    auto valueType = value.cast<TypedAttr>().getType();
+  if (llvm::isa<DenseIntOrFPElementsAttr, SparseElementsAttr>(value)) {
+    auto valueType = llvm::cast<TypedAttr>(value).getType();
     if (valueType == opType)
       return success();
-    auto arrayType = opType.dyn_cast<spirv::ArrayType>();
-    auto shapedType = valueType.dyn_cast<ShapedType>();
+    auto arrayType = llvm::dyn_cast<spirv::ArrayType>(opType);
+    auto shapedType = llvm::dyn_cast<ShapedType>(valueType);
     if (!arrayType)
       return op.emitOpError("result or element type (")
              << opType << ") does not match value type (" << valueType
              << "), must be the same or spirv.array";
 
     int numElements = arrayType.getNumElements();
     auto opElemType = arrayType.getElementType();
-    while (auto t = opElemType.dyn_cast<spirv::ArrayType>()) {
+    while (auto t = llvm::dyn_cast<spirv::ArrayType>(opElemType)) {
       numElements *= t.getNumElements();
       opElemType = t.getElementType();
     }
     if (!opElemType.isIntOrFloat())
       return op.emitOpError("only support nested array result type");
 
     auto valueElemType = shapedType.getElementType();
     if (valueElemType != opElemType) {
       return op.emitOpError("result element type (")
              << opElemType << ") does not match value element type ("
              << valueElemType << ")";
     }
 
     if (numElements != shapedType.getNumElements()) {
       return op.emitOpError("result number of elements (")
              << numElements << ") does not match value number of elements ("
              << shapedType.getNumElements() << ")";
     }
     return success();
   }
-  if (auto arrayAttr = value.dyn_cast<ArrayAttr>()) {
-    auto arrayType = opType.dyn_cast<spirv::ArrayType>();
+  if (auto arrayAttr = llvm::dyn_cast<ArrayAttr>(value)) {
+    auto arrayType = llvm::dyn_cast<spirv::ArrayType>(opType);
     if (!arrayType)
       return op.emitOpError(
           "must have spirv.array result type for array value");
     Type elemType = arrayType.getElementType();
     for (Attribute element : arrayAttr.getValue()) {
       // Verify array elements recursively.
       if (failed(verifyConstantType(op, element, elemType)))
         return failure();
     }
     return success();
   }
   return op.emitOpError("cannot have attribute: ") << value;
 }
 
 LogicalResult spirv::ConstantOp::verify() {
   // ODS already generates checks to make sure the result type is valid. We just
   // need to additionally check that the value's attribute type is consistent
   // with the result type.
   return verifyConstantType(*this, getValueAttr(), getType());
 }
 
 bool spirv::ConstantOp::isBuildableWith(Type type) {
   // Must be valid SPIR-V type first.
-  if (!type.isa<spirv::SPIRVType>())
+  if (!llvm::isa<spirv::SPIRVType>(type))
     return false;
 
   if (isa<SPIRVDialect>(type.getDialect())) {
     // TODO: support constant struct
-    return type.isa<spirv::ArrayType>();
+    return llvm::isa<spirv::ArrayType>(type);
   }
 
   return true;
 }
 
 spirv::ConstantOp spirv::ConstantOp::getZero(Type type, Location loc,
                                              OpBuilder &builder) {
-  if (auto intType = type.dyn_cast<IntegerType>()) {
+  if (auto intType = llvm::dyn_cast<IntegerType>(type)) {
     unsigned width = intType.getWidth();
     if (width == 1)
       return builder.create<spirv::ConstantOp>(loc, type,
                                                builder.getBoolAttr(false));
     return builder.create<spirv::ConstantOp>(
         loc, type, builder.getIntegerAttr(type, APInt(width, 0)));
   }
-  if (auto floatType = type.dyn_cast<FloatType>()) {
+  if (auto floatType = llvm::dyn_cast<FloatType>(type)) {
     return builder.create<spirv::ConstantOp>(
         loc, type, builder.getFloatAttr(floatType, 0.0));
   }
-  if (auto vectorType = type.dyn_cast<VectorType>()) {
+  if (auto vectorType = llvm::dyn_cast<VectorType>(type)) {
     Type elemType = vectorType.getElementType();
-    if (elemType.isa<IntegerType>()) {
+    if (llvm::isa<IntegerType>(elemType)) {
       return builder.create<spirv::ConstantOp>(
           loc, type,
           DenseElementsAttr::get(vectorType,
                                  IntegerAttr::get(elemType, 0).getValue()));
     }
-    if (elemType.isa<FloatType>()) {
+    if (llvm::isa<FloatType>(elemType)) {
       return builder.create<spirv::ConstantOp>(
           loc, type,
           DenseFPElementsAttr::get(vectorType,
                                    FloatAttr::get(elemType, 0.0).getValue()));
     }
   }
 
   llvm_unreachable("unimplemented types for ConstantOp::getZero()");
 }
 
 spirv::ConstantOp spirv::ConstantOp::getOne(Type type, Location loc,
                                             OpBuilder &builder) {
-  if (auto intType = type.dyn_cast<IntegerType>()) {
+  if (auto intType = llvm::dyn_cast<IntegerType>(type)) {
     unsigned width = intType.getWidth();
     if (width == 1)
       return builder.create<spirv::ConstantOp>(loc, type,
                                                builder.getBoolAttr(true));
     return builder.create<spirv::ConstantOp>(
         loc, type, builder.getIntegerAttr(type, APInt(width, 1)));
   }
-  if (auto floatType = type.dyn_cast<FloatType>()) {
+  if (auto floatType = llvm::dyn_cast<FloatType>(type)) {
     return builder.create<spirv::ConstantOp>(
         loc, type, builder.getFloatAttr(floatType, 1.0));
   }
-  if (auto vectorType = type.dyn_cast<VectorType>()) {
+  if (auto vectorType = llvm::dyn_cast<VectorType>(type)) {
     Type elemType = vectorType.getElementType();
-    if (elemType.isa<IntegerType>()) {
+    if (llvm::isa<IntegerType>(elemType)) {
       return builder.create<spirv::ConstantOp>(
           loc, type,
           DenseElementsAttr::get(vectorType,
                                  IntegerAttr::get(elemType, 1).getValue()));
     }
-    if (elemType.isa<FloatType>()) {
+    if (llvm::isa<FloatType>(elemType)) {
       return builder.create<spirv::ConstantOp>(
           loc, type,
           DenseFPElementsAttr::get(vectorType,
                                    FloatAttr::get(elemType, 1.0).getValue()));
     }
   }
 
   llvm_unreachable("unimplemented types for ConstantOp::getOne()");
 }
 
 void mlir::spirv::ConstantOp::getAsmResultNames(
     llvm::function_ref<void(mlir::Value, llvm::StringRef)> setNameFn) {
   Type type = getType();
 
   SmallString<32> specialNameBuffer;
   llvm::raw_svector_ostream specialName(specialNameBuffer);
   specialName << "cst";
 
-  IntegerType intTy = type.dyn_cast<IntegerType>();
+  IntegerType intTy = llvm::dyn_cast<IntegerType>(type);
 
-  if (IntegerAttr intCst = getValue().dyn_cast<IntegerAttr>()) {
+  if (IntegerAttr intCst = llvm::dyn_cast<IntegerAttr>(getValue())) {
     if (intTy && intTy.getWidth() == 1) {
       return setNameFn(getResult(), (intCst.getInt() ? "true" : "false"));
     }
 
     if (intTy.isSignless()) {
       specialName << intCst.getInt();
     } else if (intTy.isUnsigned()) {
       specialName << intCst.getUInt();
     } else {
       specialName << intCst.getSInt();
     }
   }
 
-  if (intTy || type.isa<FloatType>()) {
+  if (intTy || llvm::isa<FloatType>(type)) {
     specialName << '_' << type;
   }
 
-  if (auto vecType = type.dyn_cast<VectorType>()) {
+  if (auto vecType = llvm::dyn_cast<VectorType>(type)) {
     specialName << "_vec_";
     specialName << vecType.getDimSize(0);
 
     Type elementType = vecType.getElementType();
 
-    if (elementType.isa<IntegerType>() || elementType.isa<FloatType>()) {
+    if (llvm::isa<IntegerType>(elementType) ||
+        llvm::isa<FloatType>(elementType)) {
       specialName << "x" << elementType;
     }
   }
 
   setNameFn(getResult(), specialName.str());
 }
 
 void mlir::spirv::AddressOfOp::getAsmResultNames(

 // spirv.INTELConvertBF16ToFOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::INTELConvertBF16ToFOp::verify() {
   auto operandType = getOperand().getType();
   auto resultType = getResult().getType();
   // ODS checks that vector result type and vector operand type have the same
   // shape.
-  if (auto vectorType = operandType.dyn_cast<VectorType>()) {
+  if (auto vectorType = llvm::dyn_cast<VectorType>(operandType)) {
     unsigned operandNumElements = vectorType.getNumElements();
-    unsigned resultNumElements = resultType.cast<VectorType>().getNumElements();
+    unsigned resultNumElements =
+        llvm::cast<VectorType>(resultType).getNumElements();
     if (operandNumElements != resultNumElements) {
       return emitOpError(
           "operand and result must have same number of elements");
     }
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.INTELConvertFToBF16Op
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::INTELConvertFToBF16Op::verify() {
   auto operandType = getOperand().getType();
   auto resultType = getResult().getType();
   // ODS checks that vector result type and vector operand type have the same
   // shape.
-  if (auto vectorType = operandType.dyn_cast<VectorType>()) {
+  if (auto vectorType = llvm::dyn_cast<VectorType>(operandType)) {
     unsigned operandNumElements = vectorType.getNumElements();
-    unsigned resultNumElements = resultType.cast<VectorType>().getNumElements();
+    unsigned resultNumElements =
+        llvm::cast<VectorType>(resultType).getNumElements();
     if (operandNumElements != resultNumElements) {
       return emitOpError(
           "operand and result must have same number of elements");
     }
   }
   return success();
 }
 
ParseResult spirv::ExecutionModeOp::parse(OpAsmParser &parser,
   SmallVector<int32_t, 4> values;
   Type i32Type = parser.getBuilder().getIntegerType(32);
   while (!parser.parseOptionalComma()) {
     NamedAttrList attr;
     Attribute value;
     if (parser.parseAttribute(value, i32Type, "value", attr)) {
       return failure();
     }
-    values.push_back(value.cast<IntegerAttr>().getInt());
+    values.push_back(llvm::cast<IntegerAttr>(value).getInt());
   }
   result.addAttribute(kValuesAttrName,
                       parser.getBuilder().getI32ArrayAttr(values));
   return success();
 }
 
 void spirv::ExecutionModeOp::print(OpAsmPrinter &printer) {
   printer << " ";
   printer.printSymbolName(getFn());
   printer << " \"" << stringifyExecutionMode(getExecutionMode()) << "\"";
   auto values = this->getValues();
   if (values.empty())
     return;
   printer << ", ";
   llvm::interleaveComma(values, printer, [&](Attribute a) {
-    printer << a.cast<IntegerAttr>().getInt();
+    printer << llvm::cast<IntegerAttr>(a).getInt();
   });
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.FConvertOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::FConvertOp::verify() {
if (parseVariableDecorations(parser, result)) {
     return failure();
   }
 
   Type type;
   auto loc = parser.getCurrentLocation();
   if (parser.parseColonType(type)) {
     return failure();
   }
-  if (!type.isa<spirv::PointerType>()) {
+  if (!llvm::isa<spirv::PointerType>(type)) {
     return parser.emitError(loc, "expected spirv.ptr type");
   }
   result.addAttribute(kTypeAttrName, TypeAttr::get(type));
 
   return success();
 }
 
 void spirv::GlobalVariableOp::print(OpAsmPrinter &printer) {
void spirv::GlobalVariableOp::print(OpAsmPrinter &printer) {
   }
 
   elidedAttrs.push_back(kTypeAttrName);
   printVariableDecorations(*this, printer, elidedAttrs);
   printer << " : " << getType();
 }
 
 LogicalResult spirv::GlobalVariableOp::verify() {
-  if (!getType().isa<spirv::PointerType>())
+  if (!llvm::isa<spirv::PointerType>(getType()))
     return emitOpError("result must be of a !spv.ptr type");
 
   // SPIR-V spec: "Storage Class is the Storage Class of the memory holding the
   // object. It cannot be Generic. It must be the same as the Storage Class
   // operand of the Result Type."
   // Also, Function storage class is reserved by spirv.Variable.
   auto storageClass = this->storageClass();
   if (storageClass == spirv::StorageClass::Generic ||

 // spirv.GroupBroadcast
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::GroupBroadcastOp::verify() {
   spirv::Scope scope = getExecutionScope();
   if (scope != spirv::Scope::Workgroup && scope != spirv::Scope::Subgroup)
     return emitOpError("execution scope must be 'Workgroup' or 'Subgroup'");
 
-  if (auto localIdTy = getLocalid().getType().dyn_cast<VectorType>())
+  if (auto localIdTy = llvm::dyn_cast<VectorType>(getLocalid().getType()))
     if (localIdTy.getNumElements() != 2 && localIdTy.getNumElements() != 3)
       return emitOpError("localid is a vector and can be with only "
                          " 2 or 3 components, actual number is ")
              << localIdTy.getNumElements();
 
   return success();
 }
 
ParseResult spirv::INTELSubgroupBlockReadOp::parse(OpAsmParser &parser,
   OpAsmParser::UnresolvedOperand ptrInfo;
   Type elementType;
   if (parseEnumStrAttr(storageClass, parser) || parser.parseOperand(ptrInfo) ||
       parser.parseColon() || parser.parseType(elementType)) {
     return failure();
   }
 
   auto ptrType = spirv::PointerType::get(elementType, storageClass);
-  if (auto valVecTy = elementType.dyn_cast<VectorType>())
+  if (auto valVecTy = llvm::dyn_cast<VectorType>(elementType))
     ptrType = spirv::PointerType::get(valVecTy.getElementType(), storageClass);
 
   if (parser.resolveOperand(ptrInfo, ptrType, result.operands)) {
     return failure();
   }
 
   result.addTypes(elementType);
   return success();
ParseResult spirv::INTELSubgroupBlockWriteOp::parse(OpAsmParser &parser,
   Type elementType;
   if (parseEnumStrAttr(storageClass, parser) ||
       parser.parseOperandList(operandInfo, 2) || parser.parseColon() ||
       parser.parseType(elementType)) {
     return failure();
   }
 
   auto ptrType = spirv::PointerType::get(elementType, storageClass);
-  if (auto valVecTy = elementType.dyn_cast<VectorType>())
+  if (auto valVecTy = llvm::dyn_cast<VectorType>(elementType))
     ptrType = spirv::PointerType::get(valVecTy.getElementType(), storageClass);
 
   if (parser.resolveOperands(operandInfo, {ptrType, elementType}, loc,
                              result.operands)) {
     return failure();
   }
   return success();
 }

 
 //===----------------------------------------------------------------------===//
 // spirv.LoadOp
 //===----------------------------------------------------------------------===//
 
 void spirv::LoadOp::build(OpBuilder &builder, OperationState &state,
                           Value basePtr, MemoryAccessAttr memoryAccess,
                           IntegerAttr alignment) {
-  auto ptrType = basePtr.getType().cast<spirv::PointerType>();
+  auto ptrType = llvm::cast<spirv::PointerType>(basePtr.getType());
   build(builder, state, ptrType.getPointeeType(), basePtr, memoryAccess,
         alignment);
 }
 
 ParseResult spirv::LoadOp::parse(OpAsmParser &parser, OperationState &result) {
   // Parse the storage class specification
   spirv::StorageClass storageClass;
   OpAsmParser::UnresolvedOperand ptrInfo;
ParseResult spirv::LoadOp::parse(OpAsmParser &parser, OperationState &result) {
 
   result.addTypes(elementType);
   return success();
 }
 
 void spirv::LoadOp::print(OpAsmPrinter &printer) {
   SmallVector<StringRef, 4> elidedAttrs;
   StringRef sc = stringifyStorageClass(
-      getPtr().getType().cast<spirv::PointerType>().getStorageClass());
+      llvm::cast<spirv::PointerType>(getPtr().getType()).getStorageClass());
   printer << " \"" << sc << "\" " << getPtr();
 
   printMemoryAccessAttribute(*this, printer, elidedAttrs);
 
   printer.printOptionalAttrDict((*this)->getAttrs(), elidedAttrs);
   printer << " : " << getType();
 }
 
for (auto &op : *getBody()) {
     if (auto entryPointOp = dyn_cast<spirv::EntryPointOp>(op)) {
       auto funcOp = table.lookup<spirv::FuncOp>(entryPointOp.getFn());
       if (!funcOp) {
         return entryPointOp.emitError("function '")
                << entryPointOp.getFn() << "' not found in 'spirv.module'";
       }
       if (auto interface = entryPointOp.getInterface()) {
         for (Attribute varRef : interface) {
-          auto varSymRef = varRef.dyn_cast<FlatSymbolRefAttr>();
+          auto varSymRef = llvm::dyn_cast<FlatSymbolRefAttr>(varRef);
           if (!varSymRef) {
             return entryPointOp.emitError(
                        "expected symbol reference for interface "
                        "specification instead of '")
                    << varRef;
           }
           auto variableOp =
               table.lookup<spirv::GlobalVariableOp>(varSymRef.getValue());
LogicalResult spirv::ReturnValueOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.Select
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::SelectOp::verify() {
-  if (auto conditionTy = getCondition().getType().dyn_cast<VectorType>()) {
-    auto resultVectorTy = getResult().getType().dyn_cast<VectorType>();
+  if (auto conditionTy = llvm::dyn_cast<VectorType>(getCondition().getType())) {
+    auto resultVectorTy = llvm::dyn_cast<VectorType>(getResult().getType());
     if (!resultVectorTy) {
       return emitOpError("result expected to be of vector type when "
                          "condition is of vector type");
     }
     if (resultVectorTy.getNumElements() != conditionTy.getNumElements()) {
       return emitOpError("result should have the same number of elements as "
                          "the condition when condition is of vector type");
     }

 }
 
 LogicalResult spirv::SpecConstantOp::verify() {
   if (auto specID = (*this)->getAttrOfType<IntegerAttr>(kSpecIdAttrName))
     if (specID.getValue().isNegative())
       return emitOpError("SpecId cannot be negative");
 
   auto value = getDefaultValue();
-  if (value.isa<IntegerAttr, FloatAttr>()) {
+  if (llvm::isa<IntegerAttr, FloatAttr>(value)) {
     // Make sure bitwidth is allowed.
-    if (!value.getType().isa<spirv::SPIRVType>())
+    if (!llvm::isa<spirv::SPIRVType>(value.getType()))
       return emitOpError("default value bitwidth disallowed");
     return success();
   }
   return emitOpError(
       "default value can only be a bool, integer, or float scalar");
 }
 
 //===----------------------------------------------------------------------===//
if (parser.resolveOperands(operandInfo, {ptrType, elementType}, loc,
     return failure();
   }
   return success();
 }
 
 void spirv::StoreOp::print(OpAsmPrinter &printer) {
   SmallVector<StringRef, 4> elidedAttrs;
   StringRef sc = stringifyStorageClass(
-      getPtr().getType().cast<spirv::PointerType>().getStorageClass());
+      llvm::cast<spirv::PointerType>(getPtr().getType()).getStorageClass());
   printer << " \"" << sc << "\" " << getPtr() << ", " << getValue();
 
   printMemoryAccessAttribute(*this, printer, elidedAttrs);
 
   printer << " : " << getValue().getType();
   printer.printOptionalAttrDict((*this)->getAttrs(), elidedAttrs);
 }
 
ParseResult spirv::VariableOp::parse(OpAsmParser &parser,
   // Parse result pointer type
   Type type;
   if (parser.parseColon())
     return failure();
   auto loc = parser.getCurrentLocation();
   if (parser.parseType(type))
     return failure();
 
-  auto ptrType = type.dyn_cast<spirv::PointerType>();
+  auto ptrType = llvm::dyn_cast<spirv::PointerType>(type);
   if (!ptrType)
     return parser.emitError(loc, "expected spirv.ptr type");
   result.addTypes(ptrType);
 
   // Resolve the initializer operand
   if (initInfo) {
     if (parser.resolveOperand(*initInfo, ptrType.getPointeeType(),
                               result.operands))
LogicalResult spirv::VariableOp::verify() {
   // object. It cannot be Generic. It must be the same as the Storage Class
   // operand of the Result Type."
   if (getStorageClass() != spirv::StorageClass::Function) {
     return emitOpError(
         "can only be used to model function-level variables. Use "
         "spirv.GlobalVariable for module-level variables.");
   }
 
-  auto pointerType = getPointer().getType().cast<spirv::PointerType>();
+  auto pointerType = llvm::cast<spirv::PointerType>(getPointer().getType());
   if (getStorageClass() != pointerType.getStorageClass())
     return emitOpError(
         "storage class must match result pointer's storage class");
 
   if (getNumOperands() != 0) {
     // SPIR-V spec: "Initializer must be an <id> from a constant instruction or
     // a global (module scope) OpVariable instruction".
     auto *initOp = getOperand(0).getDefiningOp();
LogicalResult spirv::VariableOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.VectorShuffle
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::VectorShuffleOp::verify() {
-  VectorType resultType = getType().cast<VectorType>();
+  VectorType resultType = llvm::cast<VectorType>(getType());
 
   size_t numResultElements = resultType.getNumElements();
   if (numResultElements != getComponents().size())
     return emitOpError("result type element count (")
            << numResultElements
            << ") mismatch with the number of component selectors ("
            << getComponents().size() << ")";
 
   size_t totalSrcElements =
-      getVector1().getType().cast<VectorType>().getNumElements() +
-      getVector2().getType().cast<VectorType>().getNumElements();
+      llvm::cast<VectorType>(getVector1().getType()).getNumElements() +
+      llvm::cast<VectorType>(getVector2().getType()).getNumElements();
 
   for (const auto &selector : getComponents().getAsValueRange<IntegerAttr>()) {
     uint32_t index = selector.getZExtValue();
     if (index >= totalSrcElements &&
         index != std::numeric_limits<uint32_t>().max())
       return emitOpError("component selector ")
              << index << " out of range: expected to be in [0, "
              << totalSrcElements << ") or 0xffffffff";
void spirv::NVCooperativeMatrixLoadOp::print(OpAsmPrinter &printer) {
   // Print optional memory access attribute.
   if (auto memAccess = getMemoryAccess())
     printer << " [\"" << stringifyMemoryAccess(*memAccess) << "\"]";
   printer << " : " << getPointer().getType() << " as " << getType();
 }
 
 static LogicalResult verifyPointerAndCoopMatrixType(Operation *op, Type pointer,
                                                     Type coopMatrix) {
-  Type pointeeType = pointer.cast<spirv::PointerType>().getPointeeType();
-  if (!pointeeType.isa<spirv::ScalarType>() && !pointeeType.isa<VectorType>())
+  Type pointeeType = llvm::cast<spirv::PointerType>(pointer).getPointeeType();
+  if (!llvm::isa<spirv::ScalarType>(pointeeType) &&
+      !llvm::isa<VectorType>(pointeeType))
     return op->emitError(
                "Pointer must point to a scalar or vector type but provided ")
            << pointeeType;
   spirv::StorageClass storage =
-      pointer.cast<spirv::PointerType>().getStorageClass();
+      llvm::cast<spirv::PointerType>(pointer).getStorageClass();
   if (storage != spirv::StorageClass::Workgroup &&
       storage != spirv::StorageClass::StorageBuffer &&
       storage != spirv::StorageClass::PhysicalStorageBuffer)
     return op->emitError(
                "Pointer storage class must be Workgroup, StorageBuffer or "
                "PhysicalStorageBufferEXT but provided ")
            << stringifyStorageClass(storage);
   return success();

 //===----------------------------------------------------------------------===//
 // spirv.NV.CooperativeMatrixMulAdd
 //===----------------------------------------------------------------------===//
 
 static LogicalResult
 verifyCoopMatrixMulAdd(spirv::NVCooperativeMatrixMulAddOp op) {
   if (op.getC().getType() != op.getResult().getType())
     return op.emitOpError("result and third operand must have the same type");
-  auto typeA = op.getA().getType().cast<spirv::CooperativeMatrixNVType>();
-  auto typeB = op.getB().getType().cast<spirv::CooperativeMatrixNVType>();
-  auto typeC = op.getC().getType().cast<spirv::CooperativeMatrixNVType>();
-  auto typeR = op.getResult().getType().cast<spirv::CooperativeMatrixNVType>();
+  auto typeA = llvm::cast<spirv::CooperativeMatrixNVType>(op.getA().getType());
+  auto typeB = llvm::cast<spirv::CooperativeMatrixNVType>(op.getB().getType());
+  auto typeC = llvm::cast<spirv::CooperativeMatrixNVType>(op.getC().getType());
+  auto typeR =
+      llvm::cast<spirv::CooperativeMatrixNVType>(op.getResult().getType());
   if (typeA.getRows() != typeR.getRows() ||
       typeA.getColumns() != typeB.getRows() ||
       typeB.getColumns() != typeR.getColumns())
     return op.emitOpError("matrix size must match");
   if (typeR.getScope() != typeA.getScope() ||
       typeR.getScope() != typeB.getScope() ||
       typeR.getScope() != typeC.getScope())
     return op.emitOpError("matrix scope must match");
   auto elementTypeA = typeA.getElementType();
   auto elementTypeB = typeB.getElementType();
   if (isa<IntegerType>(elementTypeA) && isa<IntegerType>(elementTypeB)) {
-    if (elementTypeA.cast<IntegerType>().getWidth() !=
-        elementTypeB.cast<IntegerType>().getWidth())
+    if (llvm::cast<IntegerType>(elementTypeA).getWidth() !=
+        llvm::cast<IntegerType>(elementTypeB).getWidth())
       return op.emitOpError(
           "matrix A and B integer element types must be the same bit width");
   } else if (elementTypeA != elementTypeB) {
     return op.emitOpError(
         "matrix A and B non-integer element types must match");
   }
   if (typeR.getElementType() != typeC.getElementType())
     return op.emitOpError("matrix accumulator element type must match");
   return success();
 }
 
 LogicalResult spirv::NVCooperativeMatrixMulAddOp::verify() {
   return verifyCoopMatrixMulAdd(*this);
 }
 
 static LogicalResult
 verifyPointerAndJointMatrixType(Operation *op, Type pointer, Type jointMatrix) {
-  Type pointeeType = pointer.cast<spirv::PointerType>().getPointeeType();
-  if (!pointeeType.isa<spirv::ScalarType>() && !pointeeType.isa<VectorType>())
+  Type pointeeType = llvm::cast<spirv::PointerType>(pointer).getPointeeType();
+  if (!llvm::isa<spirv::ScalarType>(pointeeType) &&
+      !llvm::isa<VectorType>(pointeeType))
     return op->emitError(
                "Pointer must point to a scalar or vector type but provided ")
            << pointeeType;
   spirv::StorageClass storage =
-      pointer.cast<spirv::PointerType>().getStorageClass();
+      llvm::cast<spirv::PointerType>(pointer).getStorageClass();
   if (storage != spirv::StorageClass::Workgroup &&
       storage != spirv::StorageClass::CrossWorkgroup &&
       storage != spirv::StorageClass::UniformConstant &&
       storage != spirv::StorageClass::Generic)
     return op->emitError("Pointer storage class must be Workgroup or "
                          "CrossWorkgroup but provided ")
            << stringifyStorageClass(storage);
   return success();

 
 //===----------------------------------------------------------------------===//
 // spirv.INTEL.JointMatrixMad
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verifyJointMatrixMad(spirv::INTELJointMatrixMadOp op) {
   if (op.getC().getType() != op.getResult().getType())
     return op.emitOpError("result and third operand must have the same type");
-  auto typeA = op.getA().getType().cast<spirv::JointMatrixINTELType>();
-  auto typeB = op.getB().getType().cast<spirv::JointMatrixINTELType>();
-  auto typeC = op.getC().getType().cast<spirv::JointMatrixINTELType>();
-  auto typeR = op.getResult().getType().cast<spirv::JointMatrixINTELType>();
+  auto typeA = llvm::cast<spirv::JointMatrixINTELType>(op.getA().getType());
+  auto typeB = llvm::cast<spirv::JointMatrixINTELType>(op.getB().getType());
+  auto typeC = llvm::cast<spirv::JointMatrixINTELType>(op.getC().getType());
+  auto typeR =
+      llvm::cast<spirv::JointMatrixINTELType>(op.getResult().getType());
   if (typeA.getRows() != typeR.getRows() ||
       typeA.getColumns() != typeB.getRows() ||
       typeB.getColumns() != typeR.getColumns())
     return op.emitOpError("matrix size must match");
   if (typeR.getScope() != typeA.getScope() ||
       typeR.getScope() != typeB.getScope() ||
       typeR.getScope() != typeC.getScope())
     return op.emitOpError("matrix scope must match");
   if (typeA.getElementType() != typeB.getElementType() ||
       typeR.getElementType() != typeC.getElementType())
     return op.emitOpError("matrix element type must match");
   return success();
 }
 
 LogicalResult spirv::INTELJointMatrixMadOp::verify() {
   return verifyJointMatrixMad(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.MatrixTimesScalar
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::MatrixTimesScalarOp::verify() {
-  if (auto inputCoopmat =
-          getMatrix().getType().dyn_cast<spirv::CooperativeMatrixNVType>()) {
+  if (auto inputCoopmat = llvm::dyn_cast<spirv::CooperativeMatrixNVType>(
+          getMatrix().getType())) {
     if (inputCoopmat.getElementType() != getScalar().getType())
       return emitError("input matrix components' type and scaling value must "
                        "have the same type");
     return success();
   }
 
   // Check that the scalar type is the same as the matrix element type.
-  auto inputMatrix = getMatrix().getType().cast<spirv::MatrixType>();
+  auto inputMatrix = llvm::cast<spirv::MatrixType>(getMatrix().getType());
   if (getScalar().getType() != inputMatrix.getElementType())
     return emitError("input matrix components' type and scaling value must "
                      "have the same type");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.CopyMemory
 //===----------------------------------------------------------------------===//
 
 void spirv::CopyMemoryOp::print(OpAsmPrinter &printer) {
   printer << ' ';
 
   StringRef targetStorageClass = stringifyStorageClass(
-      getTarget().getType().cast<spirv::PointerType>().getStorageClass());
+      llvm::cast<spirv::PointerType>(getTarget().getType()).getStorageClass());
   printer << " \"" << targetStorageClass << "\" " << getTarget() << ", ";
 
   StringRef sourceStorageClass = stringifyStorageClass(
-      getSource().getType().cast<spirv::PointerType>().getStorageClass());
+      llvm::cast<spirv::PointerType>(getSource().getType()).getStorageClass());
   printer << " \"" << sourceStorageClass << "\" " << getSource();
 
   SmallVector<StringRef, 4> elidedAttrs;
   printMemoryAccessAttribute(*this, printer, elidedAttrs);
   printSourceMemoryAccessAttribute(*this, printer, elidedAttrs,
                                    getSourceMemoryAccess(),
                                    getSourceAlignment());
 
   printer.printOptionalAttrDict((*this)->getAttrs(), elidedAttrs);
 
   Type pointeeType =
-      getTarget().getType().cast<spirv::PointerType>().getPointeeType();
+      llvm::cast<spirv::PointerType>(getTarget().getType()).getPointeeType();
   printer << " : " << pointeeType;
 }
 
 ParseResult spirv::CopyMemoryOp::parse(OpAsmParser &parser,
                                        OperationState &result) {
   spirv::StorageClass targetStorageClass;
   OpAsmParser::UnresolvedOperand targetPtrInfo;
 
if (parser.resolveOperand(targetPtrInfo, targetPtrType, result.operands) ||
     return failure();
   }
 
   return success();
 }
 
 LogicalResult spirv::CopyMemoryOp::verify() {
   Type targetType =
-      getTarget().getType().cast<spirv::PointerType>().getPointeeType();
+      llvm::cast<spirv::PointerType>(getTarget().getType()).getPointeeType();
 
   Type sourceType =
-      getSource().getType().cast<spirv::PointerType>().getPointeeType();
+      llvm::cast<spirv::PointerType>(getSource().getType()).getPointeeType();
 
   if (targetType != sourceType)
     return emitOpError("both operands must be pointers to the same type");
 
   if (failed(verifyMemoryAccessAttribute(*this)))
     return failure();
 
   // TODO - According to the spec:
   //
   // If two masks are present, the first applies to Target and cannot include
   // MakePointerVisible, and the second applies to Source and cannot include
   // MakePointerAvailable.
   //
   // Add such verification here.
 
   return verifySourceMemoryAccessAttribute(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.Transpose
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::TransposeOp::verify() {
-  auto inputMatrix = getMatrix().getType().cast<spirv::MatrixType>();
-  auto resultMatrix = getResult().getType().cast<spirv::MatrixType>();
+  auto inputMatrix = llvm::cast<spirv::MatrixType>(getMatrix().getType());
+  auto resultMatrix = llvm::cast<spirv::MatrixType>(getResult().getType());
 
   // Verify that the input and output matrices have correct shapes.
   if (inputMatrix.getNumRows() != resultMatrix.getNumColumns())
     return emitError("input matrix rows count must be equal to "
                      "output matrix columns count");
 
   if (inputMatrix.getNumColumns() != resultMatrix.getNumRows())
     return emitError("input matrix columns count must be equal to "
                      "output matrix rows count");
 
   // Verify that the input and output matrices have the same component type
   if (inputMatrix.getElementType() != resultMatrix.getElementType())
     return emitError("input and output matrices must have the same "
                      "component type");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.MatrixTimesMatrix
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::MatrixTimesMatrixOp::verify() {
-  auto leftMatrix = getLeftmatrix().getType().cast<spirv::MatrixType>();
-  auto rightMatrix = getRightmatrix().getType().cast<spirv::MatrixType>();
-  auto resultMatrix = getResult().getType().cast<spirv::MatrixType>();
+  auto leftMatrix = llvm::cast<spirv::MatrixType>(getLeftmatrix().getType());
+  auto rightMatrix = llvm::cast<spirv::MatrixType>(getRightmatrix().getType());
+  auto resultMatrix = llvm::cast<spirv::MatrixType>(getResult().getType());
 
   // left matrix columns' count and right matrix rows' count must be equal
   if (leftMatrix.getNumColumns() != rightMatrix.getNumRows())
     return emitError("left matrix columns' count must be equal to "
                      "the right matrix rows' count");
 
   // right and result matrices columns' count must be the same
   if (rightMatrix.getNumColumns() != resultMatrix.getNumColumns())
void spirv::SpecConstantCompositeOp::print(OpAsmPrinter &printer) {
 
   if (!constituents.empty())
     llvm::interleaveComma(constituents, printer);
 
   printer << ") : " << getType();
 }
 
 LogicalResult spirv::SpecConstantCompositeOp::verify() {
-  auto cType = getType().dyn_cast<spirv::CompositeType>();
+  auto cType = llvm::dyn_cast<spirv::CompositeType>(getType());
   auto constituents = this->getConstituents().getValue();
 
   if (!cType)
     return emitError("result type must be a composite type, but provided ")
            << getType();
 
-  if (cType.isa<spirv::CooperativeMatrixNVType>())
+  if (llvm::isa<spirv::CooperativeMatrixNVType>(cType))
     return emitError("unsupported composite type  ") << cType;
-  if (cType.isa<spirv::JointMatrixINTELType>())
+  if (llvm::isa<spirv::JointMatrixINTELType>(cType))
     return emitError("unsupported composite type  ") << cType;
   if (constituents.size() != cType.getNumElements())
     return emitError("has incorrect number of operands: expected ")
            << cType.getNumElements() << ", but provided "
            << constituents.size();
 
   for (auto index : llvm::seq<uint32_t>(0, constituents.size())) {
-    auto constituent = constituents[index].cast<FlatSymbolRefAttr>();
+    auto constituent = llvm::cast<FlatSymbolRefAttr>(constituents[index]);
 
     auto constituentSpecConstOp =
         dyn_cast<spirv::SpecConstantOp>(SymbolTable::lookupNearestSymbolFrom(
             (*this)->getParentOp(), constituent.getAttr()));
 
     if (constituentSpecConstOp.getDefaultValue().getType() !=
         cType.getElementType(index))
       return emitError("has incorrect types of operands: expected ")

 }
 
 //===----------------------------------------------------------------------===//
 // spirv.GL.FrexpStruct
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::GLFrexpStructOp::verify() {
   spirv::StructType structTy =
-      getResult().getType().dyn_cast<spirv::StructType>();
+      llvm::dyn_cast<spirv::StructType>(getResult().getType());
 
   if (structTy.getNumElements() != 2)
     return emitError("result type must be a struct type with two memebers");
 
   Type significandTy = structTy.getElementType(0);
   Type exponentTy = structTy.getElementType(1);
-  VectorType exponentVecTy = exponentTy.dyn_cast<VectorType>();
-  IntegerType exponentIntTy = exponentTy.dyn_cast<IntegerType>();
+  VectorType exponentVecTy = llvm::dyn_cast<VectorType>(exponentTy);
+  IntegerType exponentIntTy = llvm::dyn_cast<IntegerType>(exponentTy);
 
   Type operandTy = getOperand().getType();
-  VectorType operandVecTy = operandTy.dyn_cast<VectorType>();
-  FloatType operandFTy = operandTy.dyn_cast<FloatType>();
+  VectorType operandVecTy = llvm::dyn_cast<VectorType>(operandTy);
+  FloatType operandFTy = llvm::dyn_cast<FloatType>(operandTy);
 
   if (significandTy != operandTy)
     return emitError("member zero of the resulting struct type must be the "
                      "same type as the operand");
 
   if (exponentVecTy) {
     IntegerType componentIntTy =
-        exponentVecTy.getElementType().dyn_cast<IntegerType>();
+        llvm::dyn_cast<IntegerType>(exponentVecTy.getElementType());
     if (!componentIntTy || componentIntTy.getWidth() != 32)
       return emitError("member one of the resulting struct type must"
                        "be a scalar or vector of 32 bit integer type");
   } else if (!exponentIntTy || exponentIntTy.getWidth() != 32) {
     return emitError("member one of the resulting struct type "
                      "must be a scalar or vector of 32 bit integer type");
   }
 

 //===----------------------------------------------------------------------===//
 // spirv.GL.Ldexp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::GLLdexpOp::verify() {
   Type significandType = getX().getType();
   Type exponentType = getExp().getType();
 
-  if (significandType.isa<FloatType>() != exponentType.isa<IntegerType>())
+  if (llvm::isa<FloatType>(significandType) !=
+      llvm::isa<IntegerType>(exponentType))
     return emitOpError("operands must both be scalars or vectors");
 
   auto getNumElements = [](Type type) -> unsigned {
-    if (auto vectorType = type.dyn_cast<VectorType>())
+    if (auto vectorType = llvm::dyn_cast<VectorType>(type))
       return vectorType.getNumElements();
     return 1;
   };
 
   if (getNumElements(significandType) != getNumElements(exponentType))
     return emitOpError("operands must have the same number of elements");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.ImageDrefGather
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::ImageDrefGatherOp::verify() {
-  VectorType resultType = getResult().getType().cast<VectorType>();
+  VectorType resultType = llvm::cast<VectorType>(getResult().getType());
   auto sampledImageType =
-      getSampledimage().getType().cast<spirv::SampledImageType>();
-  auto imageType = sampledImageType.getImageType().cast<spirv::ImageType>();
+      llvm::cast<spirv::SampledImageType>(getSampledimage().getType());
+  auto imageType =
+      llvm::cast<spirv::ImageType>(sampledImageType.getImageType());
 
   if (resultType.getNumElements() != 4)
     return emitOpError("result type must be a vector of four components");
 
   Type elementType = resultType.getElementType();
   Type sampledElementType = imageType.getElementType();
-  if (!sampledElementType.isa<NoneType>() && elementType != sampledElementType)
+  if (!llvm::isa<NoneType>(sampledElementType) &&
+      elementType != sampledElementType)
     return emitOpError(
         "the component type of result must be the same as sampled type of the "
         "underlying image type");
 
   spirv::Dim imageDim = imageType.getDim();
   spirv::ImageSamplingInfo imageMS = imageType.getSamplingInfo();
 
   if (imageDim != spirv::Dim::Dim2D && imageDim != spirv::Dim::Cube &&
LogicalResult spirv::ShiftRightLogicalOp::verify() {
   return verifyShiftOp(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // spirv.ImageQuerySize
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::ImageQuerySizeOp::verify() {
-  spirv::ImageType imageType = getImage().getType().cast<spirv::ImageType>();
+  spirv::ImageType imageType =
+      llvm::cast<spirv::ImageType>(getImage().getType());
   Type resultType = getResult().getType();
 
   spirv::Dim dim = imageType.getDim();
   spirv::ImageSamplingInfo samplingInfo = imageType.getSamplingInfo();
   spirv::ImageSamplerUseInfo samplerInfo = imageType.getSamplerUseInfo();
   switch (dim) {
   case spirv::Dim::Dim1D:
   case spirv::Dim::Dim2D:
LogicalResult spirv::ImageQuerySizeOp::verify() {
   default:
     break;
   }
 
   if (imageType.getArrayedInfo() == spirv::ImageArrayedInfo::Arrayed)
     componentNumber += 1;
 
   unsigned resultComponentNumber = 1;
-  if (auto resultVectorType = resultType.dyn_cast<VectorType>())
+  if (auto resultVectorType = llvm::dyn_cast<VectorType>(resultType))
     resultComponentNumber = resultVectorType.getNumElements();
 
   if (componentNumber != resultComponentNumber)
     return emitError("expected the result to have ")
            << componentNumber << " component(s), but found "
            << resultComponentNumber << " component(s)";
 
   return success();

 
 //===----------------------------------------------------------------------===//
 // spirv.VectorTimesScalarOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::VectorTimesScalarOp::verify() {
   if (getVector().getType() != getType())
     return emitOpError("vector operand and result type mismatch");
-  auto scalarType = getType().cast<VectorType>().getElementType();
+  auto scalarType = llvm::cast<VectorType>(getType()).getElementType();
   if (getScalar().getType() != scalarType)
     return emitOpError("scalar operand and result element type match");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Group ops
 //===----------------------------------------------------------------------===//
assert(llvm::is_contained({2u, 3u}, op->getNumOperands()) &&
          "Not an integer dot product op?");
   assert(op->getNumResults() == 1 && "Expected a single result");
 
   Type factorTy = op->getOperand(0).getType();
   if (op->getOperand(1).getType() != factorTy)
     return op->emitOpError("requires the same type for both vector operands");
 
   unsigned expectedNumAttrs = 0;
-  if (auto intTy = factorTy.dyn_cast<IntegerType>()) {
+  if (auto intTy = llvm::dyn_cast<IntegerType>(factorTy)) {
     ++expectedNumAttrs;
     auto packedVectorFormat =
-        op->getAttr(kPackedVectorFormatAttrName)
-            .dyn_cast_or_null<spirv::PackedVectorFormatAttr>();
+        llvm::dyn_cast_or_null<spirv::PackedVectorFormatAttr>(
+            op->getAttr(kPackedVectorFormatAttrName));
     if (!packedVectorFormat)
       return op->emitOpError("requires Packed Vector Format attribute for "
                              "integer vector operands");
 
     assert(packedVectorFormat.getValue() ==
                spirv::PackedVectorFormat::PackedVectorFormat4x8Bit &&
            "Unknown Packed Vector Format");
     if (intTy.getWidth() != 32)
getIntegerDotProductCapabilities(Operation *op) {
   static const auto dotProductInput4x8BitCap =
       spirv::Capability::DotProductInput4x8Bit;
   static const auto dotProductInputAllCap =
       spirv::Capability::DotProductInputAll;
 
   SmallVector<ArrayRef<spirv::Capability>, 1> capabilities = {dotProductCap};
 
   Type factorTy = op->getOperand(0).getType();
-  if (auto intTy = factorTy.dyn_cast<IntegerType>()) {
-    auto formatAttr = op->getAttr(kPackedVectorFormatAttrName)
-                          .cast<spirv::PackedVectorFormatAttr>();
+  if (auto intTy = llvm::dyn_cast<IntegerType>(factorTy)) {
+    auto formatAttr = llvm::cast<spirv::PackedVectorFormatAttr>(
+        op->getAttr(kPackedVectorFormatAttrName));
     if (formatAttr.getValue() ==
         spirv::PackedVectorFormat::PackedVectorFormat4x8Bit)
       capabilities.push_back(dotProductInput4x8BitPackedCap);
 
     return capabilities;
   }
 
-  auto vecTy = factorTy.cast<VectorType>();
+  auto vecTy = llvm::cast<VectorType>(factorTy);
   if (vecTy.getElementTypeBitWidth() == 8) {
     capabilities.push_back(dotProductInput4x8BitCap);
     return capabilities;
   }
 
   capabilities.push_back(dotProductInputAllCap);
   return capabilities;
 }

mlir/lib/Dialect/SPIRV/IR/SPIRVTypes.cpp

 unsigned ArrayType::getNumElements() const { return getImpl()->elementCount; }
 
 Type ArrayType::getElementType() const { return getImpl()->elementType; }
 
 unsigned ArrayType::getArrayStride() const { return getImpl()->stride; }
 
 void ArrayType::getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
                               std::optional<StorageClass> storage) {
-  getElementType().cast<SPIRVType>().getExtensions(extensions, storage);
+  llvm::cast<SPIRVType>(getElementType()).getExtensions(extensions, storage);
 }
 
 void ArrayType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     std::optional<StorageClass> storage) {
-  getElementType().cast<SPIRVType>().getCapabilities(capabilities, storage);
+  llvm::cast<SPIRVType>(getElementType())
+      .getCapabilities(capabilities, storage);
 }
 
 std::optional<int64_t> ArrayType::getSizeInBytes() {
-  auto elementType = getElementType().cast<SPIRVType>();
+  auto elementType = llvm::cast<SPIRVType>(getElementType());
   std::optional<int64_t> size = elementType.getSizeInBytes();
   if (!size)
     return std::nullopt;
   return (*size + getArrayStride()) * getNumElements();
 }
 
 //===----------------------------------------------------------------------===//
 // CompositeType
 //===----------------------------------------------------------------------===//
 
 bool CompositeType::classof(Type type) {
-  if (auto vectorType = type.dyn_cast<VectorType>())
+  if (auto vectorType = llvm::dyn_cast<VectorType>(type))
     return isValid(vectorType);
-  return type.isa<spirv::ArrayType, spirv::CooperativeMatrixNVType,
+  return llvm::isa<spirv::ArrayType, spirv::CooperativeMatrixNVType,
                    spirv::JointMatrixINTELType, spirv::MatrixType,
-                  spirv::RuntimeArrayType, spirv::StructType>();
+                   spirv::RuntimeArrayType, spirv::StructType>(type);
 }
 
 bool CompositeType::isValid(VectorType type) {
   switch (type.getNumElements()) {
   case 2:
   case 3:
   case 4:
   case 8:
   case 16:
     break;
   default:
     return false;
   }
-  return type.getRank() == 1 && type.getElementType().isa<ScalarType>();
+  return type.getRank() == 1 && llvm::isa<ScalarType>(type.getElementType());
 }
 
 Type CompositeType::getElementType(unsigned index) const {
   return TypeSwitch<Type, Type>(*this)
       .Case<ArrayType, CooperativeMatrixNVType, JointMatrixINTELType,
             RuntimeArrayType, VectorType>(
           [](auto type) { return type.getElementType(); })
       .Case<MatrixType>([](MatrixType type) { return type.getColumnType(); })

 void CompositeType::getExtensions(
     SPIRVType::ExtensionArrayRefVector &extensions,
     std::optional<StorageClass> storage) {
   TypeSwitch<Type>(*this)
       .Case<ArrayType, CooperativeMatrixNVType, JointMatrixINTELType,
             MatrixType, RuntimeArrayType, StructType>(
           [&](auto type) { type.getExtensions(extensions, storage); })
       .Case<VectorType>([&](VectorType type) {
-        return type.getElementType().cast<ScalarType>().getExtensions(
-            extensions, storage);
+        return llvm::cast<ScalarType>(type.getElementType())
+            .getExtensions(extensions, storage);
       })
       .Default([](Type) { llvm_unreachable("invalid composite type"); });
 }
 
 void CompositeType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     std::optional<StorageClass> storage) {
   TypeSwitch<Type>(*this)
       .Case<ArrayType, CooperativeMatrixNVType, JointMatrixINTELType,
             MatrixType, RuntimeArrayType, StructType>(
           [&](auto type) { type.getCapabilities(capabilities, storage); })
       .Case<VectorType>([&](VectorType type) {
         auto vecSize = getNumElements();
         if (vecSize == 8 || vecSize == 16) {
           static const Capability caps[] = {Capability::Vector16};
           ArrayRef<Capability> ref(caps, std::size(caps));
           capabilities.push_back(ref);
         }
-        return type.getElementType().cast<ScalarType>().getCapabilities(
-            capabilities, storage);
+        return llvm::cast<ScalarType>(type.getElementType())
+            .getCapabilities(capabilities, storage);
       })
       .Default([](Type) { llvm_unreachable("invalid composite type"); });
 }
 
 std::optional<int64_t> CompositeType::getSizeInBytes() {
   if (auto arrayType = dyn_cast<ArrayType>())
     return arrayType.getSizeInBytes();
   if (auto structType = dyn_cast<StructType>())
     return structType.getSizeInBytes();
   if (auto vectorType = dyn_cast<VectorType>()) {
     std::optional<int64_t> elementSize =
-        vectorType.getElementType().cast<ScalarType>().getSizeInBytes();
+        llvm::cast<ScalarType>(vectorType.getElementType()).getSizeInBytes();
     if (!elementSize)
       return std::nullopt;
     return *elementSize * vectorType.getNumElements();
   }
   return std::nullopt;
 }
 
 //===----------------------------------------------------------------------===//

 
 unsigned CooperativeMatrixNVType::getColumns() const {
   return getImpl()->columns;
 }
 
 void CooperativeMatrixNVType::getExtensions(
     SPIRVType::ExtensionArrayRefVector &extensions,
     std::optional<StorageClass> storage) {
-  getElementType().cast<SPIRVType>().getExtensions(extensions, storage);
+  llvm::cast<SPIRVType>(getElementType()).getExtensions(extensions, storage);
   static const Extension exts[] = {Extension::SPV_NV_cooperative_matrix};
   ArrayRef<Extension> ref(exts, std::size(exts));
   extensions.push_back(ref);
 }
 
 void CooperativeMatrixNVType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     std::optional<StorageClass> storage) {
-  getElementType().cast<SPIRVType>().getCapabilities(capabilities, storage);
+  llvm::cast<SPIRVType>(getElementType())
+      .getCapabilities(capabilities, storage);
   static const Capability caps[] = {Capability::CooperativeMatrixNV};
   ArrayRef<Capability> ref(caps, std::size(caps));
   capabilities.push_back(ref);
 }
 
 //===----------------------------------------------------------------------===//
 // JointMatrixType
 //===----------------------------------------------------------------------===//

 
 MatrixLayout JointMatrixINTELType::getMatrixLayout() const {
   return getImpl()->matrixLayout;
 }
 
 void JointMatrixINTELType::getExtensions(
     SPIRVType::ExtensionArrayRefVector &extensions,
     std::optional<StorageClass> storage) {
-  getElementType().cast<SPIRVType>().getExtensions(extensions, storage);
+  llvm::cast<SPIRVType>(getElementType()).getExtensions(extensions, storage);
   static const Extension exts[] = {Extension::SPV_INTEL_joint_matrix};
   ArrayRef<Extension> ref(exts, std::size(exts));
   extensions.push_back(ref);
 }
 
 void JointMatrixINTELType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     std::optional<StorageClass> storage) {
-  getElementType().cast<SPIRVType>().getCapabilities(capabilities, storage);
+  llvm::cast<SPIRVType>(getElementType())
+      .getCapabilities(capabilities, storage);
   static const Capability caps[] = {Capability::JointMatrixINTEL};
   ArrayRef<Capability> ref(caps, std::size(caps));
   capabilities.push_back(ref);
 }
 
 //===----------------------------------------------------------------------===//
 // ImageType
 //===----------------------------------------------------------------------===//

 StorageClass PointerType::getStorageClass() const {
   return getImpl()->storageClass;
 }
 
 void PointerType::getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
                                 std::optional<StorageClass> storage) {
   // Use this pointer type's storage class because this pointer indicates we are
   // using the pointee type in that specific storage class.
-  getPointeeType().cast<SPIRVType>().getExtensions(extensions,
-                                                   getStorageClass());
+  llvm::cast<SPIRVType>(getPointeeType())
+      .getExtensions(extensions, getStorageClass());
 
   if (auto scExts = spirv::getExtensions(getStorageClass()))
     extensions.push_back(*scExts);
 }
 
 void PointerType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     std::optional<StorageClass> storage) {
   // Use this pointer type's storage class because this pointer indicates we are
   // using the pointee type in that specific storage class.
-  getPointeeType().cast<SPIRVType>().getCapabilities(capabilities,
-                                                     getStorageClass());
+  llvm::cast<SPIRVType>(getPointeeType())
+      .getCapabilities(capabilities, getStorageClass());
 
   if (auto scCaps = spirv::getCapabilities(getStorageClass()))
     capabilities.push_back(*scCaps);
 }
 
 //===----------------------------------------------------------------------===//
 // RuntimeArrayType
 //===----------------------------------------------------------------------===//

 
 Type RuntimeArrayType::getElementType() const { return getImpl()->elementType; }
 
 unsigned RuntimeArrayType::getArrayStride() const { return getImpl()->stride; }
 
 void RuntimeArrayType::getExtensions(
     SPIRVType::ExtensionArrayRefVector &extensions,
     std::optional<StorageClass> storage) {
-  getElementType().cast<SPIRVType>().getExtensions(extensions, storage);
+  llvm::cast<SPIRVType>(getElementType()).getExtensions(extensions, storage);
 }
 
 void RuntimeArrayType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     std::optional<StorageClass> storage) {
   {
     static const Capability caps[] = {Capability::Shader};
     ArrayRef<Capability> ref(caps, std::size(caps));
     capabilities.push_back(ref);
   }
-  getElementType().cast<SPIRVType>().getCapabilities(capabilities, storage);
+  llvm::cast<SPIRVType>(getElementType())
+      .getCapabilities(capabilities, storage);
 }
 
 //===----------------------------------------------------------------------===//
 // ScalarType
 //===----------------------------------------------------------------------===//
 
 bool ScalarType::classof(Type type) {
-  if (auto floatType = type.dyn_cast<FloatType>()) {
+  if (auto floatType = llvm::dyn_cast<FloatType>(type)) {
     return isValid(floatType);
   }
-  if (auto intType = type.dyn_cast<IntegerType>()) {
+  if (auto intType = llvm::dyn_cast<IntegerType>(type)) {
     return isValid(intType);
   }
   return false;
 }
 
 bool ScalarType::isValid(FloatType type) {
   return llvm::is_contained({16u, 32u, 64u}, type.getWidth()) && !type.isBF16();
 }

 //===----------------------------------------------------------------------===//
 // SPIRVType
 //===----------------------------------------------------------------------===//
 
 bool SPIRVType::classof(Type type) {
   // Allow SPIR-V dialect types
   if (llvm::isa<SPIRVDialect>(type.getDialect()))
     return true;
-  if (type.isa<ScalarType>())
+  if (llvm::isa<ScalarType>(type))
     return true;
-  if (auto vectorType = type.dyn_cast<VectorType>())
+  if (auto vectorType = llvm::dyn_cast<VectorType>(type))
     return CompositeType::isValid(vectorType);
   return false;
 }
 
 bool SPIRVType::isScalarOrVector() {
   return isIntOrFloat() || isa<VectorType>();
 }
 
SampledImageType::getChecked(function_ref<InFlightDiagnostic()> emitError,
   return Base::getChecked(emitError, imageType.getContext(), imageType);
 }
 
 Type SampledImageType::getImageType() const { return getImpl()->imageType; }
 
 LogicalResult
 SampledImageType::verify(function_ref<InFlightDiagnostic()> emitError,
                          Type imageType) {
-  if (!imageType.isa<ImageType>())
+  if (!llvm::isa<ImageType>(imageType))
     return emitError() << "expected image type";
 
   return success();
 }
 
 void SampledImageType::getExtensions(
     SPIRVType::ExtensionArrayRefVector &extensions,
     std::optional<StorageClass> storage) {
-  getImageType().cast<ImageType>().getExtensions(extensions, storage);
+  llvm::cast<ImageType>(getImageType()).getExtensions(extensions, storage);
 }
 
 void SampledImageType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     std::optional<StorageClass> storage) {
-  getImageType().cast<ImageType>().getCapabilities(capabilities, storage);
+  llvm::cast<ImageType>(getImageType()).getCapabilities(capabilities, storage);
 }
 
 //===----------------------------------------------------------------------===//
 // StructType
 //===----------------------------------------------------------------------===//
 
 /// Type storage for SPIR-V structure types:
 ///
StructType::trySetBody(ArrayRef<Type> memberTypes,
                        ArrayRef<OffsetInfo> offsetInfo,
                        ArrayRef<MemberDecorationInfo> memberDecorations) {
   return Base::mutate(memberTypes, offsetInfo, memberDecorations);
 }
 
 void StructType::getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
                                std::optional<StorageClass> storage) {
   for (Type elementType : getElementTypes())
-    elementType.cast<SPIRVType>().getExtensions(extensions, storage);
+    llvm::cast<SPIRVType>(elementType).getExtensions(extensions, storage);
 }
 
 void StructType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     std::optional<StorageClass> storage) {
   for (Type elementType : getElementTypes())
-    elementType.cast<SPIRVType>().getCapabilities(capabilities, storage);
+    llvm::cast<SPIRVType>(elementType).getCapabilities(capabilities, storage);
 }
 
 llvm::hash_code spirv::hash_value(
     const StructType::MemberDecorationInfo &memberDecorationInfo) {
   return llvm::hash_combine(memberDecorationInfo.memberIndex,
                             memberDecorationInfo.decoration);
 }
 
LogicalResult MatrixType::verify(function_ref<InFlightDiagnostic()> emitError,
                                  Type columnType, uint32_t columnCount) {
   if (columnCount < 2 || columnCount > 4)
     return emitError() << "matrix can have 2, 3, or 4 columns only";
 
   if (!isValidColumnType(columnType))
     return emitError() << "matrix columns must be vectors of floats";
 
   /// The underlying vectors (columns) must be of size 2, 3, or 4
-  ArrayRef<int64_t> columnShape = columnType.cast<VectorType>().getShape();
+  ArrayRef<int64_t> columnShape = llvm::cast<VectorType>(columnType).getShape();
   if (columnShape.size() != 1)
     return emitError() << "matrix columns must be 1D vectors";
 
   if (columnShape[0] < 2 || columnShape[0] > 4)
     return emitError() << "matrix columns must be of size 2, 3, or 4";
 
   return success();
 }
 
 /// Returns true if the matrix elements are vectors of float elements
 bool MatrixType::isValidColumnType(Type columnType) {
-  if (auto vectorType = columnType.dyn_cast<VectorType>()) {
-    if (vectorType.getElementType().isa<FloatType>())
+  if (auto vectorType = llvm::dyn_cast<VectorType>(columnType)) {
+    if (llvm::isa<FloatType>(vectorType.getElementType()))
       return true;
   }
   return false;
 }
 
 Type MatrixType::getColumnType() const { return getImpl()->columnType; }
 
 Type MatrixType::getElementType() const {
-  return getImpl()->columnType.cast<VectorType>().getElementType();
+  return llvm::cast<VectorType>(getImpl()->columnType).getElementType();
 }
 
 unsigned MatrixType::getNumColumns() const { return getImpl()->columnCount; }
 
 unsigned MatrixType::getNumRows() const {
-  return getImpl()->columnType.cast<VectorType>().getShape()[0];
+  return llvm::cast<VectorType>(getImpl()->columnType).getShape()[0];
 }
 
 unsigned MatrixType::getNumElements() const {
   return (getImpl()->columnCount) * getNumRows();
 }
 
 void MatrixType::getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
                                std::optional<StorageClass> storage) {
-  getColumnType().cast<SPIRVType>().getExtensions(extensions, storage);
+  llvm::cast<SPIRVType>(getColumnType()).getExtensions(extensions, storage);
 }
 
 void MatrixType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     std::optional<StorageClass> storage) {
   {
     static const Capability caps[] = {Capability::Matrix};
     ArrayRef<Capability> ref(caps, std::size(caps));
     capabilities.push_back(ref);
   }
   // Add any capabilities associated with the underlying vectors (i.e., columns)
-  getColumnType().cast<SPIRVType>().getCapabilities(capabilities, storage);
+  llvm::cast<SPIRVType>(getColumnType()).getCapabilities(capabilities, storage);
 }
 
 //===----------------------------------------------------------------------===//
 // SPIR-V Dialect
 //===----------------------------------------------------------------------===//
 
 void SPIRVDialect::registerTypes() {
   addTypes<ArrayType, CooperativeMatrixNVType, ImageType, JointMatrixINTELType,
            MatrixType, PointerType, RuntimeArrayType, SampledImageType,
            StructType>();
 }

mlir/lib/Dialect/Shape/IR/Shape.cpp

 #include "ShapeCanonicalization.inc"
 } // namespace
 
 RankedTensorType shape::getExtentTensorType(MLIRContext *ctx, int64_t rank) {
   return RankedTensorType::get({rank}, IndexType::get(ctx));
 }
 
 bool shape::isExtentTensorType(Type type) {
-  auto ranked = type.dyn_cast<RankedTensorType>();
+  auto ranked = llvm::dyn_cast<RankedTensorType>(type);
   return ranked && ranked.getRank() == 1 && ranked.getElementType().isIndex();
 }
 
 LogicalResult shape::getShapeVec(Value input,
                                  SmallVectorImpl<int64_t> &shapeValues) {
   if (auto inputOp = input.getDefiningOp<ShapeOfOp>()) {
-    auto type = inputOp.getArg().getType().cast<ShapedType>();
+    auto type = llvm::cast<ShapedType>(inputOp.getArg().getType());
     if (!type.hasRank())
       return failure();
     llvm::append_range(shapeValues, type.getShape());
     return success();
   }
   DenseIntElementsAttr attr;
   if (matchPattern(input, m_Constant(&attr))) {
     llvm::append_range(shapeValues, attr.getValues<int64_t>());
     return success();
   }
   return failure();
 }
 
 static bool isErrorPropagationPossible(TypeRange operandTypes) {
   return llvm::any_of(operandTypes, [](Type ty) {
-    return ty.isa<SizeType, ShapeType, ValueShapeType>();
+    return llvm::isa<SizeType, ShapeType, ValueShapeType>(ty);
   });
 }
 
 static LogicalResult verifySizeOrIndexOp(Operation *op) {
   assert(op != nullptr && op->getNumResults() == 1);
   Type resultTy = op->getResultTypes().front();
   if (isErrorPropagationPossible(op->getOperandTypes())) {
-    if (!resultTy.isa<SizeType>())
+    if (!llvm::isa<SizeType>(resultTy))
       return op->emitOpError()
              << "if at least one of the operands can hold error values then "
                 "the result must be of type `size` to propagate them";
   }
   return success();
 }
 
 static LogicalResult verifyShapeOrExtentTensorOp(Operation *op) {
   assert(op != nullptr && op->getNumResults() == 1);
   Type resultTy = op->getResultTypes().front();
   if (isErrorPropagationPossible(op->getOperandTypes())) {
-    if (!resultTy.isa<ShapeType>())
+    if (!llvm::isa<ShapeType>(resultTy))
       return op->emitOpError()
              << "if at least one of the operands can hold error values then "
                 "the result must be of type `shape` to propagate them";
   }
   return success();
 }
 
 template <typename... Ty>
 static bool eachHasOnlyOneOfTypes(TypeRange typeRange) {
-  return typeRange.size() == 1 && typeRange.front().isa<Ty...>();
+  return typeRange.size() == 1 && llvm::isa<Ty...>(typeRange.front());
 }
 
 template <typename... Ty, typename... ranges>
 static bool eachHasOnlyOneOfTypes(TypeRange l, ranges... rs) {
   return eachHasOnlyOneOfTypes<Ty...>(l) && eachHasOnlyOneOfTypes<Ty...>(rs...);
 }
 
 //===----------------------------------------------------------------------===//
#include "mlir/Dialect/Shape/IR/ShapeOpsTypes.cpp.inc"
   // still evolving it makes it simple to start with an unregistered ops and
   // try different variants before actually defining the op.
   allowUnknownOperations();
 }
 
 Operation *ShapeDialect::materializeConstant(OpBuilder &builder,
                                              Attribute value, Type type,
                                              Location loc) {
-  if (type.isa<ShapeType>() || isExtentTensorType(type))
-    return builder.create<ConstShapeOp>(loc, type,
-                                        value.cast<DenseIntElementsAttr>());
-  if (type.isa<SizeType>())
-    return builder.create<ConstSizeOp>(loc, type, value.cast<IntegerAttr>());
-  if (type.isa<WitnessType>())
-    return builder.create<ConstWitnessOp>(loc, type, value.cast<BoolAttr>());
+  if (llvm::isa<ShapeType>(type) || isExtentTensorType(type))
+    return builder.create<ConstShapeOp>(
+        loc, type, llvm::cast<DenseIntElementsAttr>(value));
+  if (llvm::isa<SizeType>(type))
+    return builder.create<ConstSizeOp>(loc, type,
+                                       llvm::cast<IntegerAttr>(value));
+  if (llvm::isa<WitnessType>(type))
+    return builder.create<ConstWitnessOp>(loc, type,
+                                          llvm::cast<BoolAttr>(value));
   return arith::ConstantOp::materialize(builder, value, type, loc);
 }
 
 LogicalResult ShapeDialect::verifyOperationAttribute(Operation *op,
                                                      NamedAttribute attribute) {
   // Verify shape.lib attribute.
   if (attribute.getName() == "shape.lib") {
     if (!op->hasTrait<OpTrait::SymbolTable>())
       return op->emitError(
           "shape.lib attribute may only be on op implementing SymbolTable");
 
-    if (auto symbolRef = attribute.getValue().dyn_cast<SymbolRefAttr>()) {
+    if (auto symbolRef = llvm::dyn_cast<SymbolRefAttr>(attribute.getValue())) {
       auto *symbol = SymbolTable::lookupSymbolIn(op, symbolRef);
       if (!symbol)
         return op->emitError("shape function library ")
                << symbolRef << " not found";
       return isa<shape::FunctionLibraryOp>(symbol)
                  ? success()
                  : op->emitError()
                        << symbolRef << " required to be shape function library";
     }
 
-    if (auto arr = attribute.getValue().dyn_cast<ArrayAttr>()) {
+    if (auto arr = llvm::dyn_cast<ArrayAttr>(attribute.getValue())) {
       // Verify all entries are function libraries and mappings in libraries
       // refer to unique ops.
       DenseSet<StringAttr> key;
       for (auto it : arr) {
-        if (!it.isa<SymbolRefAttr>())
+        if (!llvm::isa<SymbolRefAttr>(it))
           return op->emitError(
               "only SymbolRefAttr allowed in shape.lib attribute array");
 
         auto shapeFnLib = dyn_cast<shape::FunctionLibraryOp>(
-            SymbolTable::lookupSymbolIn(op, it.cast<SymbolRefAttr>()));
+            SymbolTable::lookupSymbolIn(op, llvm::cast<SymbolRefAttr>(it)));
         if (!shapeFnLib)
           return op->emitError()
                  << it << " does not refer to FunctionLibraryOp";
         for (auto mapping : shapeFnLib.getMapping()) {
           if (!key.insert(mapping.getName()).second) {
             return op->emitError("only one op to shape mapping allowed, found "
                                  "multiple for `")
                    << mapping.getName() << "`";

 //===----------------------------------------------------------------------===//
 // AddOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult mlir::shape::AddOp::inferReturnTypes(
     MLIRContext *context, std::optional<Location> location, ValueRange operands,
     DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (operands[0].getType().isa<SizeType>() ||
-      operands[1].getType().isa<SizeType>())
+  if (llvm::isa<SizeType>(operands[0].getType()) ||
+      llvm::isa<SizeType>(operands[1].getType()))
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::AddOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   // SizeType is compatible with IndexType.
for (int idx = adaptor.getInputs().size() - 1; idx >= 0; idx--) {
     if (!a)
       return nullptr;
 
     // We do not need to keep statically known values after handling them in
     // this method.
     getOperation()->eraseOperand(idx);
 
     // Always false if any input is statically known false
-    if (!a.cast<BoolAttr>().getValue())
+    if (!llvm::cast<BoolAttr>(a).getValue())
       return a;
   }
   // If this is reached, all inputs were statically known passing.
   return BoolAttr::get(getContext(), true);
 }
 
 LogicalResult AssumingAllOp::verify() {
   // Ensure that AssumingAllOp contains at least one operand
OpFoldResult BroadcastOp::fold(FoldAdaptor adaptor) {
 
   // TODO: Support folding with more than 2 input shapes
   if (getShapes().size() > 2)
     return nullptr;
 
   if (!adaptor.getShapes()[0] || !adaptor.getShapes()[1])
     return nullptr;
   auto lhsShape = llvm::to_vector<6>(
-      adaptor.getShapes()[0].cast<DenseIntElementsAttr>().getValues<int64_t>());
+      llvm::cast<DenseIntElementsAttr>(adaptor.getShapes()[0])
+          .getValues<int64_t>());
   auto rhsShape = llvm::to_vector<6>(
-      adaptor.getShapes()[1].cast<DenseIntElementsAttr>().getValues<int64_t>());
+      llvm::cast<DenseIntElementsAttr>(adaptor.getShapes()[1])
+          .getValues<int64_t>());
   SmallVector<int64_t, 6> resultShape;
 
   // If the shapes are not compatible, we can't fold it.
   // TODO: Fold to an "error".
   if (!OpTrait::util::getBroadcastedShape(lhsShape, rhsShape, resultShape))
     return nullptr;
 
   Builder builder(getContext());
   return builder.getIndexTensorAttr(resultShape);
 }
 
 LogicalResult BroadcastOp::verify() {
   return verifyShapeOrExtentTensorOp(*this);
 }
 
 namespace {
 template <typename OpTy>
 struct RemoveEmptyShapeOperandsPattern : public OpRewritePattern<OpTy> {
   using OpRewritePattern<OpTy>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(OpTy op,
                                 PatternRewriter &rewriter) const override {
     auto isPotentiallyNonEmptyShape = [](Value shape) {
-      if (auto extentTensorTy = shape.getType().dyn_cast<RankedTensorType>()) {
+      if (auto extentTensorTy =
+              llvm::dyn_cast<RankedTensorType>(shape.getType())) {
         if (extentTensorTy.getDimSize(0) == 0)
           return false;
       }
       if (auto constShape = shape.getDefiningOp<ConstShapeOp>()) {
         if (constShape.getShape().empty())
           return false;
       }
       return true;
LogicalResult matchAndRewrite(BroadcastOp op,
                                 PatternRewriter &rewriter) const override {
     if (op.getNumOperands() != 1)
       return failure();
     Value replacement = op.getShapes().front();
 
     // Insert cast if needed.
     if (replacement.getType() != op.getType()) {
       auto loc = op.getLoc();
-      if (op.getType().isa<ShapeType>()) {
+      if (llvm::isa<ShapeType>(op.getType())) {
         replacement = rewriter.create<FromExtentTensorOp>(loc, replacement);
       } else {
-        assert(!op.getType().isa<ShapeType>() &&
-               !replacement.getType().isa<ShapeType>() &&
+        assert(!llvm::isa<ShapeType>(op.getType()) &&
+               !llvm::isa<ShapeType>(replacement.getType()) &&
                "expect extent tensor cast");
         replacement =
             rewriter.create<tensor::CastOp>(loc, op.getType(), replacement);
       }
     }
 
     rewriter.replaceOp(op, replacement);
     return success();
struct CanonicalizeCastExtentTensorOperandsPattern
   LogicalResult matchAndRewrite(OpTy op,
                                 PatternRewriter &rewriter) const override {
     // Canonicalize operands.
     bool anyChange = false;
     auto canonicalizeOperand = [&](Value operand) -> Value {
       if (auto castOp = operand.getDefiningOp<tensor::CastOp>()) {
         // Only eliminate the cast if it holds no shape information.
         bool isInformationLoosingCast =
-            castOp.getType().cast<RankedTensorType>().isDynamicDim(0);
+            llvm::cast<RankedTensorType>(castOp.getType()).isDynamicDim(0);
         if (isInformationLoosingCast) {
           anyChange = true;
           return castOp.getSource();
         }
       }
       return operand;
     };
     auto newOperands = llvm::to_vector<8>(

 
 struct BroadcastConcretizeResultTypePattern
     : public OpRewritePattern<BroadcastOp> {
   using OpRewritePattern<BroadcastOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(BroadcastOp op,
                                 PatternRewriter &rewriter) const override {
     // Only concretize dynamic extent tensor result types.
-    auto resultTy = op.getType().dyn_cast<RankedTensorType>();
+    auto resultTy = llvm::dyn_cast<RankedTensorType>(op.getType());
     if (!resultTy || !resultTy.isDynamicDim(0))
       return failure();
 
     // Infer resulting shape rank if possible.
     int64_t maxRank = 0;
     for (Value shape : op.getShapes()) {
-      if (auto extentTensorTy = shape.getType().dyn_cast<RankedTensorType>()) {
+      if (auto extentTensorTy =
+              llvm::dyn_cast<RankedTensorType>(shape.getType())) {
         // Cannot infer resulting shape rank if any operand is dynamically
         // ranked.
         if (extentTensorTy.isDynamicDim(0))
           return failure();
         maxRank = std::max(maxRank, extentTensorTy.getDimSize(0));
       }
     }
 
if (parser.parseOptionalAttrDict(result.attributes))
     return failure();
   // We piggy-back on ArrayAttr parsing, though we don't internally store the
   // shape as an ArrayAttr.
   // TODO: Implement custom parser and maybe make syntax a bit more concise.
   Attribute extentsRaw;
   NamedAttrList dummy;
   if (parser.parseAttribute(extentsRaw, "dummy", dummy))
     return failure();
-  auto extentsArray = extentsRaw.dyn_cast<ArrayAttr>();
+  auto extentsArray = llvm::dyn_cast<ArrayAttr>(extentsRaw);
   if (!extentsArray)
     return failure();
   SmallVector<int64_t, 6> ints;
   for (Attribute extent : extentsArray) {
-    IntegerAttr attr = extent.dyn_cast<IntegerAttr>();
+    IntegerAttr attr = llvm::dyn_cast<IntegerAttr>(extent);
     if (!attr)
       return failure();
     ints.push_back(attr.getInt());
   }
   Builder &builder = parser.getBuilder();
   result.addAttribute("shape", builder.getIndexTensorAttr(ints));
   Type resultTy;
   if (parser.parseColonType(resultTy))

 bool mlir::shape::ConstShapeOp::isCompatibleReturnTypes(TypeRange l,
                                                         TypeRange r) {
   if (l.size() != 1 || r.size() != 1)
     return false;
 
   Type lhs = l.front();
   Type rhs = r.front();
 
-  if (lhs.isa<ShapeType>() || rhs.isa<ShapeType>())
+  if (llvm::isa<ShapeType>(lhs) || llvm::isa<ShapeType>(rhs))
     // Shape type is compatible with all other valid return types.
     return true;
   return lhs == rhs;
 }
 
 //===----------------------------------------------------------------------===//
 // CstrBroadcastableOp
 //===----------------------------------------------------------------------===//
patterns.add<CanonicalizeCastExtentTensorOperandsPattern<CstrBroadcastableOp>,
                RemoveEmptyShapeOperandsPattern<CstrBroadcastableOp>>(context);
 }
 
 // Return true if there is exactly one attribute not representing a scalar
 // broadcast.
 static bool hasAtMostSingleNonScalar(ArrayRef<Attribute> attributes) {
   bool nonScalarSeen = false;
   for (Attribute a : attributes) {
-    if (!a || a.cast<DenseIntElementsAttr>().getNumElements() != 0) {
+    if (!a || llvm::cast<DenseIntElementsAttr>(a).getNumElements() != 0) {
       if (nonScalarSeen)
         return false;
       nonScalarSeen = true;
     }
   }
   return true;
 }
 

 //===----------------------------------------------------------------------===//
 // DimOp
 //===----------------------------------------------------------------------===//
 
 std::optional<int64_t> DimOp::getConstantIndex() {
   if (auto constSizeOp = getIndex().getDefiningOp<ConstSizeOp>())
     return constSizeOp.getValue().getLimitedValue();
   if (auto constantOp = getIndex().getDefiningOp<arith::ConstantOp>())
-    return constantOp.getValue().cast<IntegerAttr>().getInt();
+    return llvm::cast<IntegerAttr>(constantOp.getValue()).getInt();
   return std::nullopt;
 }
 
 OpFoldResult DimOp::fold(FoldAdaptor adaptor) {
   Type valType = getValue().getType();
-  auto valShapedType = valType.dyn_cast<ShapedType>();
+  auto valShapedType = llvm::dyn_cast<ShapedType>(valType);
   if (!valShapedType || !valShapedType.hasRank())
     return nullptr;
   std::optional<int64_t> index = getConstantIndex();
   if (!index.has_value())
     return nullptr;
   if (index.value() >= valShapedType.getRank())
     return nullptr;
   auto extent = valShapedType.getDimSize(*index);
LogicalResult mlir::shape::DimOp::inferReturnTypes(
   return success();
 }
 
 bool mlir::shape::DimOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   return eachHasOnlyOneOfTypes<SizeType, IndexType>(l, r);
 }
 
 LogicalResult mlir::shape::DimOp::verify() {
-  auto st = getValue().getType().cast<ShapedType>();
+  auto st = llvm::cast<ShapedType>(getValue().getType());
   if (!st.hasRank())
     return success();
   if (auto index = getConstantIndex()) {
     if (*index < 0 || *index >= st.getRank())
       return emitOpError("index is out of range");
   }
   return success();
 }
OpFoldResult DivOp::fold(FoldAdaptor adaptor) {
   Type indexTy = IndexType::get(getContext());
   return IntegerAttr::get(indexTy, quotient);
 }
 
 LogicalResult mlir::shape::DivOp::inferReturnTypes(
     MLIRContext *context, std::optional<Location> location, ValueRange operands,
     DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (operands[0].getType().isa<SizeType>() ||
-      operands[1].getType().isa<SizeType>())
+  if (llvm::isa<SizeType>(operands[0].getType()) ||
+      llvm::isa<SizeType>(operands[1].getType()))
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::DivOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   // SizeType is compatible with IndexType.

 // FromExtentsOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult FromExtentsOp::fold(FoldAdaptor adaptor) {
   if (llvm::any_of(adaptor.getExtents(), [](Attribute a) { return !a; }))
     return nullptr;
   SmallVector<int64_t, 6> extents;
   for (auto attr : adaptor.getExtents())
-    extents.push_back(attr.cast<IntegerAttr>().getInt());
+    extents.push_back(llvm::cast<IntegerAttr>(attr).getInt());
   Builder builder(getContext());
   return builder.getIndexTensorAttr(extents);
 }
 
 //===----------------------------------------------------------------------===//
 // FunctionLibraryOp
 //===----------------------------------------------------------------------===//
 
 void FunctionLibraryOp::build(OpBuilder &builder, OperationState &result,
                               StringRef name) {
   result.attributes.push_back(builder.getNamedAttr(
       ::mlir::SymbolTable::getSymbolAttrName(), builder.getStringAttr(name)));
 }
 
 FuncOp FunctionLibraryOp::getShapeFunction(Operation *op) {
-  auto attr = getMapping()
-                  .get(op->getName().getIdentifier())
-                  .dyn_cast_or_null<FlatSymbolRefAttr>();
+  auto attr = llvm::dyn_cast_or_null<FlatSymbolRefAttr>(
+      getMapping().get(op->getName().getIdentifier()));
   if (!attr)
     return nullptr;
   return lookupSymbol<FuncOp>(attr);
 }
 
 ParseResult FunctionLibraryOp::parse(OpAsmParser &parser,
                                      OperationState &result) {
   // Parse the op name.

 //===----------------------------------------------------------------------===//
 // GetExtentOp
 //===----------------------------------------------------------------------===//
 
 std::optional<int64_t> GetExtentOp::getConstantDim() {
   if (auto constSizeOp = getDim().getDefiningOp<ConstSizeOp>())
     return constSizeOp.getValue().getLimitedValue();
   if (auto constantOp = getDim().getDefiningOp<arith::ConstantOp>())
-    return constantOp.getValue().cast<IntegerAttr>().getInt();
+    return llvm::cast<IntegerAttr>(constantOp.getValue()).getInt();
   return std::nullopt;
 }
 
 OpFoldResult GetExtentOp::fold(FoldAdaptor adaptor) {
   auto elements = adaptor.getShape().dyn_cast_or_null<DenseIntElementsAttr>();
   if (!elements)
     return nullptr;
   std::optional<int64_t> dim = getConstantDim();
   if (!dim.has_value())
     return nullptr;
   if (dim.value() >= elements.getNumElements())
     return nullptr;
   return elements.getValues<Attribute>()[(uint64_t)dim.value()];
 }
 
 void GetExtentOp::build(OpBuilder &builder, OperationState &result, Value shape,
                         int64_t dim) {
   auto loc = result.location;
   auto dimAttr = builder.getIndexAttr(dim);
-  if (shape.getType().isa<ShapeType>()) {
+  if (llvm::isa<ShapeType>(shape.getType())) {
     Value dim = builder.create<ConstSizeOp>(loc, dimAttr);
     build(builder, result, builder.getType<SizeType>(), shape, dim);
   } else {
     Value dim =
         builder.create<arith::ConstantOp>(loc, builder.getIndexType(), dimAttr);
     build(builder, result, builder.getIndexType(), shape, dim);
   }
 }

 LogicalResult mlir::shape::MeetOp::inferReturnTypes(
     MLIRContext *context, std::optional<Location> location, ValueRange operands,
     DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands.empty())
     return failure();
 
   auto isShapeType = [](Type arg) {
-    if (arg.isa<ShapeType>())
+    if (llvm::isa<ShapeType>(arg))
       return true;
     return isExtentTensorType(arg);
   };
 
   ValueRange::type_range types = operands.getTypes();
   Type acc = types.front();
   for (auto t : drop_begin(types)) {
     Type l = acc, r = t;
-    if (!l.isa<ShapeType, SizeType>())
+    if (!llvm::isa<ShapeType, SizeType>(l))
       std::swap(l, r);
 
     // Handle sizes, propagate error type if present.
-    if (l.isa<SizeType>()) {
-      if (r.isa<SizeType, IndexType>())
+    if (llvm::isa<SizeType>(l)) {
+      if (llvm::isa<SizeType, IndexType>(r))
         acc = l;
       else
         return emitOptionalError(location, "requires all sizes or shapes");
-    } else if (l.isa<IndexType>()) {
-      if (r.isa<IndexType>())
+    } else if (llvm::isa<IndexType>(l)) {
+      if (llvm::isa<IndexType>(r))
         acc = r;
       else
         return emitOptionalError(location, "requires all sizes or shapes");
-    } else if (l.isa<ShapeType>()) {
+    } else if (llvm::isa<ShapeType>(l)) {
       // Handle shapes, propagate error type if present.
       if (isShapeType(r))
         acc = l;
       else
         return emitOptionalError(location, "requires all sizes or shapes");
     } else if (isExtentTensorType(l)) {
-      auto rank1 = l.cast<RankedTensorType>().getShape()[0];
-      auto rank2 = r.cast<RankedTensorType>().getShape()[0];
+      auto rank1 = llvm::cast<RankedTensorType>(l).getShape()[0];
+      auto rank2 = llvm::cast<RankedTensorType>(r).getShape()[0];
       if (ShapedType::isDynamic(rank1))
         acc = l;
       else if (ShapedType::isDynamic(rank2))
         acc = r;
       else if (rank1 != rank2)
         return emitOptionalError(location, "unequal shape cardinality");
       else
         acc = l;
     }
   }
   inferredReturnTypes.assign({acc});
   return success();
 }
 
 bool mlir::shape::MeetOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   if (l.size() != 1 || r.size() != 1)
     return false;
   if (l == r)
     return true;
 
   Type lhs = l.front();
   Type rhs = r.front();
 
-  if (!lhs.isa<ShapeType, SizeType>())
+  if (!llvm::isa<ShapeType, SizeType>(lhs))
     std::swap(lhs, rhs);
 
-  if (lhs.isa<SizeType>())
-    return rhs.isa<SizeType, IndexType>();
-  if (lhs.isa<ShapeType>())
-    return rhs.isa<ShapeType, TensorType>();
+  if (llvm::isa<SizeType>(lhs))
+    return llvm::isa<SizeType, IndexType>(rhs);
+  if (llvm::isa<ShapeType>(lhs))
+    return llvm::isa<ShapeType, TensorType>(rhs);
 
   if (succeeded(verifyCompatibleShapes({lhs, rhs})))
     return true;
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // RankOp
struct RankShapeOfCanonicalizationPattern
   using OpRewritePattern<shape::RankOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(shape::RankOp op,
                                 PatternRewriter &rewriter) const override {
     auto shapeOfOp = op.getShape().getDefiningOp<ShapeOfOp>();
     if (!shapeOfOp)
       return failure();
     auto rankedTensorType =
-        shapeOfOp.getArg().getType().dyn_cast<RankedTensorType>();
+        llvm::dyn_cast<RankedTensorType>(shapeOfOp.getArg().getType());
     if (!rankedTensorType)
       return failure();
     int64_t rank = rankedTensorType.getRank();
-    if (op.getType().isa<IndexType>()) {
+    if (llvm::isa<IndexType>(op.getType())) {
       rewriter.replaceOpWithNewOp<arith::ConstantIndexOp>(op.getOperation(),
                                                           rank);
-    } else if (op.getType().isa<shape::SizeType>()) {
+    } else if (llvm::isa<shape::SizeType>(op.getType())) {
       rewriter.replaceOpWithNewOp<shape::ConstSizeOp>(op.getOperation(), rank);
     } else {
       return failure();
     }
     return success();
   }
 };
 } // namespace
 
 void shape::RankOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                 MLIRContext *context) {
   patterns.add<RankShapeOfCanonicalizationPattern>(context);
 }
 
 LogicalResult mlir::shape::RankOp::inferReturnTypes(
     MLIRContext *context, std::optional<Location> location, ValueRange operands,
     DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (operands[0].getType().isa<ShapeType>())
+  if (llvm::isa<ShapeType>(operands[0].getType()))
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::RankOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   // SizeType is compatible with IndexType.

 OpFoldResult NumElementsOp::fold(FoldAdaptor adaptor) {
 
   // Fold only when argument constant.
   Attribute shape = adaptor.getShape();
   if (!shape)
     return {};
 
   APInt product(64, 1);
-  for (auto value : shape.cast<DenseIntElementsAttr>())
+  for (auto value : llvm::cast<DenseIntElementsAttr>(shape))
     product *= value;
   Builder builder(getContext());
   return builder.getIndexAttr(product.getLimitedValue());
 }
 
 LogicalResult mlir::shape::NumElementsOp::inferReturnTypes(
     MLIRContext *context, std::optional<Location> location, ValueRange operands,
     DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (operands[0].getType().isa<ShapeType>())
+  if (llvm::isa<ShapeType>(operands[0].getType()))
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::NumElementsOp::isCompatibleReturnTypes(TypeRange l,
                                                          TypeRange r) {
LogicalResult mlir::shape::MaxOp::inferReturnTypes(
   else
     inferredReturnTypes.assign({SizeType::get(context)});
   return success();
 }
 
 bool mlir::shape::MaxOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   if (l.size() != 1 || r.size() != 1)
     return false;
-  if (l.front().isa<ShapeType>() && r.front().isa<ShapeType>())
+  if (llvm::isa<ShapeType>(l.front()) && llvm::isa<ShapeType>(r.front()))
     return true;
-  if (l.front().isa<SizeType>() && r.front().isa<SizeType>())
+  if (llvm::isa<SizeType>(l.front()) && llvm::isa<SizeType>(r.front()))
     return true;
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // MinOp
 //===----------------------------------------------------------------------===//
 
LogicalResult mlir::shape::MinOp::inferReturnTypes(
   else
     inferredReturnTypes.assign({SizeType::get(context)});
   return success();
 }
 
 bool mlir::shape::MinOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   if (l.size() != 1 || r.size() != 1)
     return false;
-  if (l.front().isa<ShapeType>() && r.front().isa<ShapeType>())
+  if (llvm::isa<ShapeType>(l.front()) && llvm::isa<ShapeType>(r.front()))
     return true;
-  if (l.front().isa<SizeType>() && r.front().isa<SizeType>())
+  if (llvm::isa<SizeType>(l.front()) && llvm::isa<SizeType>(r.front()))
     return true;
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // MulOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult MulOp::fold(FoldAdaptor adaptor) {
   auto lhs = adaptor.getLhs().dyn_cast_or_null<IntegerAttr>();
   if (!lhs)
     return nullptr;
   auto rhs = adaptor.getRhs().dyn_cast_or_null<IntegerAttr>();
   if (!rhs)
     return nullptr;
   APInt folded = lhs.getValue() * rhs.getValue();
   Type indexTy = IndexType::get(getContext());
   return IntegerAttr::get(indexTy, folded);
 }
 
 LogicalResult mlir::shape::MulOp::inferReturnTypes(
     MLIRContext *context, std::optional<Location> location, ValueRange operands,
     DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (operands[0].getType().isa<SizeType>() ||
-      operands[1].getType().isa<SizeType>())
+  if (llvm::isa<SizeType>(operands[0].getType()) ||
+      llvm::isa<SizeType>(operands[1].getType()))
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::MulOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   // SizeType is compatible with IndexType.
   return eachHasOnlyOneOfTypes<SizeType, IndexType>(l, r);
 }
 
 LogicalResult shape::MulOp::verify() { return verifySizeOrIndexOp(*this); }
 
 //===----------------------------------------------------------------------===//
 // ShapeOfOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult ShapeOfOp::fold(FoldAdaptor) {
-  auto type = getOperand().getType().dyn_cast<ShapedType>();
+  auto type = llvm::dyn_cast<ShapedType>(getOperand().getType());
   if (!type || !type.hasStaticShape())
     return nullptr;
   Builder builder(getContext());
   return builder.getIndexTensorAttr(type.getShape());
 }
 
 namespace {
 struct ShapeOfWithTensor : public OpRewritePattern<shape::ShapeOfOp> {
   using OpRewritePattern<shape::ShapeOfOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(shape::ShapeOfOp op,
                                 PatternRewriter &rewriter) const override {
-    if (!op.getArg().getType().isa<ShapedType>())
+    if (!llvm::isa<ShapedType>(op.getArg().getType()))
       return failure();
-    if (op.getType().isa<ShapedType>())
+    if (llvm::isa<ShapedType>(op.getType()))
       return failure();
 
     rewriter.replaceOpWithNewOp<shape::ShapeOfOp>(op.getOperation(),
                                                   op.getArg());
     return success();
   }
 };
 
 // Canonicalize
 // ```
 // %0 = shape.shape_of %arg : tensor<?x?x?xf32> -> tensor<3xindex>
 // %1 = tensor.cast %0 : tensor<3xindex> to tensor<?xindex>
 // ```
 // to
 // ```
 // %1 = shape.shape_of %arg : tensor<?x?x?xf32> -> tensor<?xindex>
 // ```
 struct ShapeOfCastExtentTensor : public OpRewritePattern<tensor::CastOp> {
   using OpRewritePattern<tensor::CastOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tensor::CastOp op,
                                 PatternRewriter &rewriter) const override {
-    auto ty = op.getType().dyn_cast<RankedTensorType>();
+    auto ty = llvm::dyn_cast<RankedTensorType>(op.getType());
     if (!ty || ty.getRank() != 1)
       return failure();
 
     auto shapeOfOp = op.getSource().getDefiningOp<ShapeOfOp>();
     if (!shapeOfOp)
       return failure();
 
     // Argument type must be ranked and must not conflict.
-    auto argTy = shapeOfOp.getArg().getType().dyn_cast<RankedTensorType>();
+    auto argTy = llvm::dyn_cast<RankedTensorType>(shapeOfOp.getArg().getType());
     if (!argTy || (!ty.isDynamicDim(0) && ty.getDimSize(0) != argTy.getRank()))
       return failure();
 
     rewriter.replaceOpWithNewOp<ShapeOfOp>(op, ty, shapeOfOp.getArg());
     return success();
   }
 };
 } // namespace
 
 void ShapeOfOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                             MLIRContext *context) {
   patterns.add<ShapeOfCastExtentTensor, ShapeOfWithTensor,
                ExtractFromShapeOfExtentTensor>(context);
 }
 
 LogicalResult mlir::shape::ShapeOfOp::inferReturnTypes(
     MLIRContext *context, std::optional<Location> location, ValueRange operands,
     DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (operands[0].getType().isa<ValueShapeType>())
+  if (llvm::isa<ValueShapeType>(operands[0].getType()))
     inferredReturnTypes.assign({ShapeType::get(context)});
   else {
-    auto shapedTy = operands[0].getType().cast<ShapedType>();
+    auto shapedTy = llvm::cast<ShapedType>(operands[0].getType());
     int64_t rank =
         shapedTy.hasRank() ? shapedTy.getRank() : ShapedType::kDynamic;
     Type indexTy = IndexType::get(context);
     Type extentTensorTy = RankedTensorType::get({rank}, indexTy);
     inferredReturnTypes.assign({extentTensorTy});
   }
   return success();
 }
 
 bool mlir::shape::ShapeOfOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   if (l.size() != 1 || r.size() != 1)
     return false;
   if (l == r)
     return true;
 
   Type lhs = l.front();
   Type rhs = r.front();
 
-  if (!lhs.isa<ShapeType, ShapedType>() || !rhs.isa<ShapeType, ShapedType>())
+  if (!llvm::isa<ShapeType, ShapedType>(lhs) ||
+      !llvm::isa<ShapeType, ShapedType>(rhs))
     return false;
 
-  if (lhs.isa<ShapeType>() || rhs.isa<ShapeType>())
+  if (llvm::isa<ShapeType>(lhs) || llvm::isa<ShapeType>(rhs))
     // Shape type is compatible with all other valid return types.
     return true;
 
   if (succeeded(verifyCompatibleShapes({lhs, rhs})))
     return true;
   return false;
 }
 

 void SizeToIndexOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                 MLIRContext *context) {
   patterns.add<IndexToSizeToIndexCanonicalization>(context);
 }
 
 bool SizeToIndexOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   if (inputs.size() != 1 || outputs.size() != 1)
     return false;
-  return inputs[0].isa<IndexType, SizeType>() && outputs[0].isa<IndexType>();
+  return llvm::isa<IndexType, SizeType>(inputs[0]) &&
+         llvm::isa<IndexType>(outputs[0]);
 }
 
 //===----------------------------------------------------------------------===//
 // YieldOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult shape::YieldOp::verify() {
   auto *parentOp = (*this)->getParentOp();
OpFoldResult ToExtentTensorOp::fold(FoldAdaptor adaptor) {
   auto type = RankedTensorType::get({static_cast<int64_t>(shape.size())},
                                     builder.getIndexType());
   return DenseIntElementsAttr::get(type, shape);
 }
 
 bool ToExtentTensorOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   if (inputs.size() != 1 || outputs.size() != 1)
     return false;
-  if (auto inputTensor = inputs[0].dyn_cast<RankedTensorType>()) {
-    if (!inputTensor.getElementType().isa<IndexType>() ||
+  if (auto inputTensor = llvm::dyn_cast<RankedTensorType>(inputs[0])) {
+    if (!llvm::isa<IndexType>(inputTensor.getElementType()) ||
         inputTensor.getRank() != 1)
       return false;
-  } else if (!inputs[0].isa<ShapeType>()) {
+  } else if (!llvm::isa<ShapeType>(inputs[0])) {
     return false;
   }
 
-  TensorType outputTensor = outputs[0].dyn_cast<TensorType>();
-  return outputTensor && outputTensor.getElementType().isa<IndexType>();
+  TensorType outputTensor = llvm::dyn_cast<TensorType>(outputs[0]);
+  return outputTensor && llvm::isa<IndexType>(outputTensor.getElementType());
 }
 
 //===----------------------------------------------------------------------===//
 // ReduceOp
 //===----------------------------------------------------------------------===//
 
 void ReduceOp::build(OpBuilder &builder, OperationState &result, Value shape,
                      ValueRange initVals) {
   result.addOperands(shape);
   result.addOperands(initVals);
 
   Region *bodyRegion = result.addRegion();
   bodyRegion->push_back(new Block);
   Block &bodyBlock = bodyRegion->front();
   bodyBlock.addArgument(builder.getIndexType(), result.location);
 
   Type elementType;
-  if (auto tensorType = shape.getType().dyn_cast<TensorType>())
+  if (auto tensorType = llvm::dyn_cast<TensorType>(shape.getType()))
     elementType = tensorType.getElementType();
   else
     elementType = SizeType::get(builder.getContext());
   bodyBlock.addArgument(elementType, shape.getLoc());
 
   for (Value initVal : initVals) {
     bodyBlock.addArgument(initVal.getType(), initVal.getLoc());
     result.addTypes(initVal.getType());
   }
 }
 
 LogicalResult ReduceOp::verify() {
   // Verify block arg types.
   Block &block = getRegion().front();
 
   // The block takes index, extent, and aggregated values as arguments.
   auto blockArgsCount = getInitVals().size() + 2;
   if (block.getNumArguments() != blockArgsCount)
     return emitOpError() << "ReduceOp body is expected to have "
                          << blockArgsCount << " arguments";
 
   // The first block argument is the index and must always be of type `index`.
-  if (!block.getArgument(0).getType().isa<IndexType>())
+  if (!llvm::isa<IndexType>(block.getArgument(0).getType()))
     return emitOpError(
         "argument 0 of ReduceOp body is expected to be of IndexType");
 
   // The second block argument is the extent and must be of type `size` or
   // `index`, depending on whether the reduce operation is applied to a shape or
   // to an extent tensor.
   Type extentTy = block.getArgument(1).getType();
-  if (getShape().getType().isa<ShapeType>()) {
-    if (!extentTy.isa<SizeType>())
+  if (llvm::isa<ShapeType>(getShape().getType())) {
+    if (!llvm::isa<SizeType>(extentTy))
       return emitOpError("argument 1 of ReduceOp body is expected to be of "
                          "SizeType if the ReduceOp operates on a ShapeType");
   } else {
-    if (!extentTy.isa<IndexType>())
+    if (!llvm::isa<IndexType>(extentTy))
       return emitOpError(
           "argument 1 of ReduceOp body is expected to be of IndexType if the "
           "ReduceOp operates on an extent tensor");
   }
 
   for (const auto &type : llvm::enumerate(getInitVals()))
     if (block.getArgument(type.index() + 2).getType() != type.value().getType())
       return emitOpError() << "type mismatch between argument "

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

while (succeeded(parser.parseOptionalKeyword(&attrName))) {
     RETURN_ON_FAIL(parser.parseEqual())
     // FIXME: using `operator==` below duplicates the string comparison
     // cost of the `is_contained` check above. Should instead use some
     // "find" function that returns the index into `keys` so that we can
     // dispatch on that instead.
     if (attrName == "dimLevelType") {
       Attribute attr;
       RETURN_ON_FAIL(parser.parseAttribute(attr));
-      auto arrayAttr = attr.dyn_cast<ArrayAttr>();
+      auto arrayAttr = llvm::dyn_cast<ArrayAttr>(attr);
       ERROR_IF(!arrayAttr, "expected an array for dimension level types")
       for (auto i : arrayAttr) {
-        auto strAttr = i.dyn_cast<StringAttr>();
+        auto strAttr = llvm::dyn_cast<StringAttr>(i);
         ERROR_IF(!strAttr, "expected a string value in dimension level types")
         auto strVal = strAttr.getValue();
         if (auto optDLT = parseDLT(strVal)) {
           lvlTypes.push_back(optDLT.value());
         } else {
           parser.emitError(parser.getNameLoc(),
                            "unexpected dimension level type: ")
               << strVal;
           return {};
         }
       }
     } else if (attrName == "dimOrdering") {
       Attribute attr;
       RETURN_ON_FAIL(parser.parseAttribute(attr))
-      auto affineAttr = attr.dyn_cast<AffineMapAttr>();
+      auto affineAttr = llvm::dyn_cast<AffineMapAttr>(attr);
       ERROR_IF(!affineAttr, "expected an affine map for dimension ordering")
       dimOrd = affineAttr.getValue();
     } else if (attrName == "higherOrdering") {
       Attribute attr;
       RETURN_ON_FAIL(parser.parseAttribute(attr))
-      auto affineAttr = attr.dyn_cast<AffineMapAttr>();
+      auto affineAttr = llvm::dyn_cast<AffineMapAttr>(attr);
       ERROR_IF(!affineAttr, "expected an affine map for higher ordering")
       higherOrd = affineAttr.getValue();
     } else if (attrName == "posWidth") {
       Attribute attr;
       RETURN_ON_FAIL(parser.parseAttribute(attr))
-      auto intAttr = attr.dyn_cast<IntegerAttr>();
+      auto intAttr = llvm::dyn_cast<IntegerAttr>(attr);
       ERROR_IF(!intAttr, "expected an integral position bitwidth")
       posWidth = intAttr.getInt();
     } else if (attrName == "crdWidth") {
       Attribute attr;
       RETURN_ON_FAIL(parser.parseAttribute(attr))
-      auto intAttr = attr.dyn_cast<IntegerAttr>();
+      auto intAttr = llvm::dyn_cast<IntegerAttr>(attr);
       ERROR_IF(!intAttr, "expected an integral index bitwidth")
       crdWidth = intAttr.getInt();
     } else if (attrName == "slice") {
       RETURN_ON_FAIL(parser.parseLSquare())
       // Dispatches to DimSliceAttr to skip mnemonic
       bool finished = false;
       while (auto attr = SparseTensorDimSliceAttr::parse(parser, nullptr)) {
-        auto sliceAttr = attr.cast<SparseTensorDimSliceAttr>();
+        auto sliceAttr = llvm::cast<SparseTensorDimSliceAttr>(attr);
         slices.push_back(sliceAttr);
         if (parser.parseOptionalComma().failed()) {
           finished = true;
           break;
         }
       }
       // Wrong when parsing slices
       if (!finished)

 }
 
 //===----------------------------------------------------------------------===//
 // Convenience Methods.
 //===----------------------------------------------------------------------===//
 
 SparseTensorEncodingAttr
 mlir::sparse_tensor::getSparseTensorEncoding(Type type) {
-  if (auto ttp = type.dyn_cast<RankedTensorType>())
-    return ttp.getEncoding().dyn_cast_or_null<SparseTensorEncodingAttr>();
-  if (auto mdtp = type.dyn_cast<StorageSpecifierType>())
+  if (auto ttp = llvm::dyn_cast<RankedTensorType>(type))
+    return llvm::dyn_cast_or_null<SparseTensorEncodingAttr>(ttp.getEncoding());
+  if (auto mdtp = llvm::dyn_cast<StorageSpecifierType>(type))
     return mdtp.getEncoding();
   return nullptr;
 }
 
 bool mlir::sparse_tensor::isCOOType(SparseTensorEncodingAttr enc,
                                     Level startLvl, bool isUnique) {
   if (!enc ||
       !(enc.isCompressedLvl(startLvl) || enc.isCompressedWithHiLvl(startLvl)))
return verifyPackUnPack(*this, false, srcTp, valuesTp, coordinatesTp,
                           getBatchedLvlsAttr());
 }
 
 unsigned UnpackOp::getNumBatchedLvls() {
   return getBatchedLvls().has_value() ? getBatchedLvls()->getZExtValue() : 0;
 }
 
 LogicalResult ConvertOp::verify() {
-  if (auto tp1 = getSource().getType().dyn_cast<RankedTensorType>()) {
-    if (auto tp2 = getDest().getType().dyn_cast<RankedTensorType>()) {
+  if (auto tp1 = llvm::dyn_cast<RankedTensorType>(getSource().getType())) {
+    if (auto tp2 = llvm::dyn_cast<RankedTensorType>(getDest().getType())) {
       if (tp1.getRank() != tp2.getRank())
         return emitError("unexpected conversion mismatch in rank");
       auto dstEnc =
-          tp2.getEncoding().dyn_cast_or_null<SparseTensorEncodingAttr>();
+          llvm::dyn_cast_or_null<SparseTensorEncodingAttr>(tp2.getEncoding());
       if (dstEnc && dstEnc.isSlice())
         return emitError("cannot convert to a sparse tensor slice");
 
       auto shape1 = tp1.getShape();
       auto shape2 = tp2.getShape();
       // Accept size matches between the source and the destination type
       // (e.g. 10 vs. 10, 10 vs. ?, or ? vs. ?), but reject direct mismatches or
       // matches that would need a runtime assert (e.g. 10 vs. 20 or ? vs. 10).

mlir/lib/Dialect/SparseTensor/Transforms/SparseVectorization.cpp

 /// Generates a vectorized load lhs = a[ind[lo:hi]] or lhs = a[lo:hi],
 /// where 'lo' denotes the current index and 'hi = lo + vl - 1'. Note
 /// that the sparse compiler can only generate indirect loads in
 /// the last index, i.e. back().
 static Value genVectorLoad(PatternRewriter &rewriter, Location loc, VL vl,
                            Value mem, ArrayRef<Value> idxs, Value vmask) {
   VectorType vtp = vectorType(vl, mem);
   Value pass = constantZero(rewriter, loc, vtp);
-  if (idxs.back().getType().isa<VectorType>()) {
+  if (llvm::isa<VectorType>(idxs.back().getType())) {
     SmallVector<Value> scalarArgs(idxs.begin(), idxs.end());
     Value indexVec = idxs.back();
     scalarArgs.back() = constantIndex(rewriter, loc, 0);
     return rewriter.create<vector::GatherOp>(loc, vtp, mem, scalarArgs,
                                              indexVec, vmask, pass);
   }
   return rewriter.create<vector::MaskedLoadOp>(loc, vtp, mem, idxs, vmask,
                                                pass);
 }
 
 /// Generates a vectorized store a[ind[lo:hi]] = rhs or a[lo:hi] = rhs
 /// where 'lo' denotes the current index and 'hi = lo + vl - 1'. Note
 /// that the sparse compiler can only generate indirect stores in
 /// the last index, i.e. back().
 static void genVectorStore(PatternRewriter &rewriter, Location loc, Value mem,
                            ArrayRef<Value> idxs, Value vmask, Value rhs) {
-  if (idxs.back().getType().isa<VectorType>()) {
+  if (llvm::isa<VectorType>(idxs.back().getType())) {
     SmallVector<Value> scalarArgs(idxs.begin(), idxs.end());
     Value indexVec = idxs.back();
     scalarArgs.back() = constantIndex(rewriter, loc, 0);
     rewriter.create<vector::ScatterOp>(loc, mem, scalarArgs, indexVec, vmask,
                                        rhs);
     return;
   }
   rewriter.create<vector::MaskedStoreOp>(loc, mem, idxs, vmask, rhs);
if (isInvariantValue(sub, block)) {
         idxs.push_back(sub);
       continue; // success so far
     }
     // Invariant block arguments (including outer loop indices) in outer
     // dimensions simply pass through. Direct loop indices in the
     // innermost loop simply pass through as well.
     // Example:
     //   a[i][j] for both i and j
-    if (auto arg = sub.dyn_cast<BlockArgument>()) {
+    if (auto arg = llvm::dyn_cast<BlockArgument>(sub)) {
       if (isInvariantArg(arg, block) == innermost)
         return false;
       if (codegen)
         idxs.push_back(sub);
       continue; // success so far
     }
     // Look under the hood of casting.
     auto cast = sub;
for (auto sub : subs) {
     if (auto load = cast.getDefiningOp<memref::LoadOp>()) {
       if (!innermost)
         return false;
       if (codegen) {
         SmallVector<Value> idxs2(load.getIndices()); // no need to analyze
         Location loc = forOp.getLoc();
         Value vload =
             genVectorLoad(rewriter, loc, vl, load.getMemRef(), idxs2, vmask);
-        Type etp = vload.getType().cast<VectorType>().getElementType();
-        if (!etp.isa<IndexType>()) {
+        Type etp = llvm::cast<VectorType>(vload.getType()).getElementType();
+        if (!llvm::isa<IndexType>(etp)) {
           if (etp.getIntOrFloatBitWidth() < 32)
             vload = rewriter.create<arith::ExtUIOp>(
                 loc, vectorType(vl, rewriter.getI32Type()), vload);
           else if (etp.getIntOrFloatBitWidth() < 64 && !vl.enableSIMDIndex32)
             vload = rewriter.create<arith::ExtUIOp>(
                 loc, vectorType(vl, rewriter.getI64Type()), vload);
         }
         idxs.push_back(vload);
       }
       continue; // success so far
     }
     // Address calculation 'i = add inv, idx' (after LICM).
     // Example:
     //    a[base + i]
     if (auto load = cast.getDefiningOp<arith::AddIOp>()) {
       Value inv = load.getOperand(0);
       Value idx = load.getOperand(1);
       if (isInvariantValue(inv, block)) {
-        if (auto arg = idx.dyn_cast<BlockArgument>()) {
+        if (auto arg = llvm::dyn_cast<BlockArgument>(idx)) {
           if (isInvariantArg(arg, block) || !innermost)
             return false;
           if (codegen)
             idxs.push_back(
                 rewriter.create<arith::AddIOp>(forOp.getLoc(), inv, idx));
           continue; // success so far
         }
       }

 /// relatively simple expressions inside the for-loops.
 static bool vectorizeExpr(PatternRewriter &rewriter, scf::ForOp forOp, VL vl,
                           Value exp, bool codegen, Value vmask, Value &vexp) {
   Location loc = forOp.getLoc();
   // Reject unsupported types.
   if (!VectorType::isValidElementType(exp.getType()))
     return false;
   // A block argument is invariant/reduction/index.
-  if (auto arg = exp.dyn_cast<BlockArgument>()) {
+  if (auto arg = llvm::dyn_cast<BlockArgument>(exp)) {
     if (arg == forOp.getInductionVar()) {
       // We encountered a single, innermost index inside the computation,
       // such as a[i] = i, which must convert to [i, i+1, ...].
       if (codegen) {
         VectorType vtp = vectorType(vl, arg.getType());
         Value veci = rewriter.create<vector::BroadcastOp>(loc, vtp, arg);
         Value incr;
         if (vl.enableVLAVectorization) {

mlir/lib/Dialect/Tensor/IR/TensorInferTypeOpInterfaceImpl.cpp

return llvm::to_vector<4>(llvm::map_range(
       }));
 }
 
 static SmallVector<OpFoldResult, 4>
 getReshapeOutputShapeFromInputShape(OpBuilder &builder, Location loc, Value src,
                                     ArrayRef<int64_t> dstStaticShape,
                                     ArrayRef<AffineMap> reassocation) {
   return dstStaticShape.size() >
-                 static_cast<size_t>(src.getType().cast<ShapedType>().getRank())
+                 static_cast<size_t>(
+                     llvm::cast<ShapedType>(src.getType()).getRank())
              ? getExpandedOutputShapeFromInputShape(
                    builder, loc, src, dstStaticShape, reassocation)
              : getCollapsedOutputShapeFromInputShape(
                    builder, loc, src, dstStaticShape, reassocation);
 }
 
 template <typename OpTy>
 struct ReifyExpandOrCollapseShapeOp
for (auto dim : llvm::seq<int64_t>(0, padOp.getSourceType().getRank())) {
       unsigned numSymbols = 0;
       auto addOpFoldResult = [&](OpFoldResult valueOrAttr) {
         if (Value v = valueOrAttr.dyn_cast<Value>()) {
           expr = expr + b.getAffineSymbolExpr(numSymbols++);
           mapOperands.push_back(v);
           return;
         }
         int64_t staticValue =
-            valueOrAttr.get<Attribute>().cast<IntegerAttr>().getInt();
+            llvm::cast<IntegerAttr>(valueOrAttr.get<Attribute>()).getInt();
         expr = expr + staticValue;
       };
       addOpFoldResult(lowPad[dim]);
       addOpFoldResult(highPad[dim]);
       shapes.push_back(affine::applyMapToValues(
           b, loc, AffineMap::get(1, numSymbols, expr), mapOperands)[0]);
     }
     reifiedReturnShapes.emplace_back(std::move(shapes));

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

 /// the desired resultant type.
 Operation *TensorDialect::materializeConstant(OpBuilder &builder,
                                               Attribute value, Type type,
                                               Location loc) {
   if (auto op = arith::ConstantOp::materialize(builder, value, type, loc))
     return op;
   if (complex::ConstantOp::isBuildableWith(value, type))
     return builder.create<complex::ConstantOp>(loc, type,
-                                               value.cast<ArrayAttr>());
+                                               llvm::cast<ArrayAttr>(value));
   return nullptr;
 }
 
 SmallVector<OpFoldResult> tensor::getMixedSizes(OpBuilder &builder,
                                                 Location loc, Value value) {
-  auto tensorType = value.getType().cast<RankedTensorType>();
+  auto tensorType = llvm::cast<RankedTensorType>(value.getType());
   SmallVector<OpFoldResult> result;
   for (int64_t i = 0; i < tensorType.getRank(); ++i) {
     if (tensorType.isDynamicDim(i)) {
       Value size = builder.create<tensor::DimOp>(loc, value, i);
       result.push_back(size);
     } else {
       result.push_back(builder.getIndexAttr(tensorType.getDimSize(i)));
     }
   }
   return result;
 }
 
 FailureOr<Value> tensor::getOrCreateDestination(OpBuilder &b, Location loc,
                                                 OpResult opResult) {
-  auto tensorType = opResult.getType().dyn_cast<TensorType>();
+  auto tensorType = llvm::dyn_cast<TensorType>(opResult.getType());
   assert(tensorType && "expected tensor type");
 
   // If the op has a destination, it implements DestinationStyleOpInterface and
   // we can query the destination operand from that interface.
   auto destOp = opResult.getDefiningOp<DestinationStyleOpInterface>();
   if (destOp)
     return destOp.getTiedOpOperand(opResult)->get();
 
Value emptyTensor =
       b.create<tensor::EmptyOp>(loc, mixedSizes, tensorType.getElementType());
   return emptyTensor;
 }
 
 LogicalResult tensor::getOrCreateDestinations(OpBuilder &b, Location loc,
                                               Operation *op,
                                               SmallVector<Value> &result) {
   for (OpResult opResult : op->getResults()) {
-    if (opResult.getType().isa<TensorType>()) {
+    if (llvm::isa<TensorType>(opResult.getType())) {
       FailureOr<Value> destination = getOrCreateDestination(b, loc, opResult);
       if (failed(destination))
         return failure();
       result.push_back(*destination);
     }
   }
   return success();
 }
 
 bool tensor::isSameTypeWithoutEncoding(Type tp1, Type tp2) {
-  if (auto rtp1 = tp1.dyn_cast<RankedTensorType>()) {
-    if (auto rtp2 = tp2.dyn_cast<RankedTensorType>())
+  if (auto rtp1 = llvm::dyn_cast<RankedTensorType>(tp1)) {
+    if (auto rtp2 = llvm::dyn_cast<RankedTensorType>(tp2))
       return rtp1.getShape() == rtp2.getShape() &&
              rtp1.getElementType() == rtp2.getElementType();
     return false;
   }
   return tp1 == tp2; // default implementation
 }
 
 /// Compute the dropped dimensions of a rank-reducing tensor.extract_slice op or
 /// rank-extending tensor.insert_slice op.
 static llvm::SmallBitVector getDroppedDims(ArrayRef<int64_t> reducedShape,
                                            ArrayRef<OpFoldResult> mixedSizes) {
   llvm::SmallBitVector droppedDims(mixedSizes.size());
   int64_t shapePos = 0;
 
   for (const auto &size : enumerate(mixedSizes)) {
     // Rank-reduced dims must have a static unit dimension.
     bool isStaticUnitSize =
         size.value().is<Attribute>() &&
-        size.value().get<Attribute>().cast<IntegerAttr>().getInt() == 1;
+        llvm::cast<IntegerAttr>(size.value().get<Attribute>()).getInt() == 1;
 
     if (shapePos == static_cast<int64_t>(reducedShape.size())) {
       // There are no more dims in the reduced shape. All remaining sizes must
       // be rank-reduced dims.
       assert(isStaticUnitSize && "expected unit dim");
       droppedDims.set(size.index());
       continue;
     }

 
 void CastOp::getAsmResultNames(function_ref<void(Value, StringRef)> setNameFn) {
   setNameFn(getResult(), "cast");
 }
 
 /// Returns true if `target` is a ranked tensor type that preserves static
 /// information available in the `source` ranked tensor type.
 bool mlir::tensor::preservesStaticInformation(Type source, Type target) {
-  auto sourceType = source.dyn_cast<RankedTensorType>();
-  auto targetType = target.dyn_cast<RankedTensorType>();
+  auto sourceType = llvm::dyn_cast<RankedTensorType>(source);
+  auto targetType = llvm::dyn_cast<RankedTensorType>(target);
 
   // Requires RankedTensorType.
   if (!sourceType || !targetType)
     return false;
 
   // Requires same elemental type.
   if (sourceType.getElementType() != targetType.getElementType())
     return false;
LogicalResult mlir::tensor::foldTensorCast(Operation *op) {
   }
   return success(folded);
 }
 
 bool CastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   if (inputs.size() != 1 || outputs.size() != 1)
     return false;
   Type a = inputs.front(), b = outputs.front();
-  auto aT = a.dyn_cast<TensorType>();
-  auto bT = b.dyn_cast<TensorType>();
+  auto aT = llvm::dyn_cast<TensorType>(a);
+  auto bT = llvm::dyn_cast<TensorType>(b);
   if (!aT || !bT)
     return false;
 
   if (aT.getElementType() != bT.getElementType())
     return false;
 
   return succeeded(verifyCompatibleShape(aT, bT));
 }
struct ChainedTensorCast : public OpRewritePattern<CastOp> {
   LogicalResult matchAndRewrite(CastOp tensorCast,
                                 PatternRewriter &rewriter) const final {
     auto tensorCastOperand = tensorCast.getOperand().getDefiningOp<CastOp>();
 
     if (!tensorCastOperand)
       return failure();
 
     auto sourceType =
-        tensorCastOperand.getOperand().getType().cast<TensorType>();
-    auto intermediateType = tensorCastOperand.getType().cast<TensorType>();
-    auto resultType = tensorCast.getType().cast<TensorType>();
+        llvm::cast<TensorType>(tensorCastOperand.getOperand().getType());
+    auto intermediateType = llvm::cast<TensorType>(tensorCastOperand.getType());
+    auto resultType = llvm::cast<TensorType>(tensorCast.getType());
 
     // We can remove the intermediate cast if joining all three produces the
     // same result as just joining the source and result shapes.
     auto firstJoin =
         joinShapes(joinShapes(sourceType, intermediateType), resultType);
 
     // The join might not exist if the cast sequence would fail at runtime.
     if (!firstJoin)
struct TensorCastExtractSlice : public OpRewritePattern<CastOp> {
   using OpRewritePattern<CastOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(CastOp tensorCast,
                                 PatternRewriter &rewriter) const final {
     auto extractOperand =
         tensorCast.getOperand().getDefiningOp<ExtractSliceOp>();
 
     // Cannot fold cast to unranked tensor.
-    auto rankedResultType = tensorCast.getType().dyn_cast<RankedTensorType>();
+    auto rankedResultType =
+        llvm::dyn_cast<RankedTensorType>(tensorCast.getType());
     if (!rankedResultType)
       return failure();
 
     if (!extractOperand || !canFoldIntoProducerOp(tensorCast) ||
-        rankedResultType.getShape() == tensorCast.getSource()
-                                           .getType()
-                                           .cast<RankedTensorType>()
-                                           .getShape())
+        rankedResultType.getShape() ==
+            llvm::cast<RankedTensorType>(tensorCast.getSource().getType())
       return failure();
 
     SmallVector<OpFoldResult, 4> sizes = extractOperand.getMixedSizes();
     auto dimMask = computeRankReductionMask(
         extractOperand.getStaticSizes(), extractOperand.getType().getShape());
     size_t dimIndex = 0;
     for (size_t i = 0, e = sizes.size(); i < e; i++) {
       if (dimMask && dimMask->count(i))

 
 OpFoldResult DimOp::fold(FoldAdaptor adaptor) {
   // All forms of folding require a known index.
   auto index = adaptor.getIndex().dyn_cast_or_null<IntegerAttr>();
   if (!index)
     return {};
 
   // Folding for unranked types (UnrankedTensorType) is not supported.
-  auto tensorType = getSource().getType().dyn_cast<RankedTensorType>();
+  auto tensorType = llvm::dyn_cast<RankedTensorType>(getSource().getType());
   if (!tensorType)
     return {};
 
   // Out of bound indices produce undefined behavior but are still valid IR.
   // Don't choke on them.
   int64_t indexVal = index.getInt();
   if (indexVal < 0 || indexVal >= tensorType.getRank())
     return {};
 
   // Fold if the shape extent along the given index is known.
   if (!tensorType.isDynamicDim(index.getInt())) {
     Builder builder(getContext());
     return builder.getIndexAttr(tensorType.getShape()[index.getInt()]);
   }
 
   Operation *definingOp = getSource().getDefiningOp();
 
   // Fold dim to the operand of tensor.generate.
   if (auto fromElements = dyn_cast_or_null<tensor::GenerateOp>(definingOp)) {
     auto resultType =
-        fromElements.getResult().getType().cast<RankedTensorType>();
+        llvm::cast<RankedTensorType>(fromElements.getResult().getType());
     // The case where the type encodes the size of the dimension is handled
     // above.
     assert(ShapedType::isDynamic(resultType.getShape()[index.getInt()]));
 
     // Find the operand of the fromElements that corresponds to this index.
     auto dynExtents = fromElements.getDynamicExtents().begin();
     for (auto dim : resultType.getShape().take_front(index.getInt()))
       if (ShapedType::isDynamic(dim))
struct FoldEmptyTensorWithCastOp : public OpRewritePattern<CastOp> {
   LogicalResult matchAndRewrite(CastOp castOp,
                                 PatternRewriter &rewriter) const override {
     if (!canFoldIntoProducerOp(castOp))
       return failure();
     auto producer = castOp.getSource().getDefiningOp<EmptyOp>();
     if (!producer)
       return failure();
 
-    auto resultType = castOp->getResult(0).getType().cast<RankedTensorType>();
+    auto resultType =
+        llvm::cast<RankedTensorType>(castOp->getResult(0).getType());
     ArrayRef<int64_t> resultShape = resultType.getShape();
     SmallVector<OpFoldResult> currMixedSizes = producer.getMixedSizes();
     SmallVector<OpFoldResult> newMixedSizes;
     newMixedSizes.reserve(currMixedSizes.size());
     assert(resultShape.size() == currMixedSizes.size() &&
            "mismatch in result shape and sizes of empty op");
     for (auto it : llvm::zip(resultShape, currMixedSizes)) {
       int64_t newDim = std::get<0>(it);
       OpFoldResult currDim = std::get<1>(it);
       // Case 1: The empty tensor dim is static. Check that the tensor cast
       // result dim matches.
       if (auto attr = currDim.dyn_cast<Attribute>()) {
         if (ShapedType::isDynamic(newDim) ||
-            newDim != attr.cast<IntegerAttr>().getInt()) {
+            newDim != llvm::cast<IntegerAttr>(attr).getInt()) {
           // Something is off, the cast result shape cannot be more dynamic
           // than the empty tensor result shape (enforced by
           // `canFoldIntoProducer`). Abort for now.
           return rewriter.notifyMatchFailure(
               producer, "mismatch in static value of shape of empty tensor "
                         "result and cast result");
         }
         newMixedSizes.push_back(attr);

 struct ExtractFromTensorCast : public OpRewritePattern<tensor::ExtractOp> {
   using OpRewritePattern<tensor::ExtractOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tensor::ExtractOp extract,
                                 PatternRewriter &rewriter) const final {
     auto tensorCast = extract.getTensor().getDefiningOp<tensor::CastOp>();
     if (!tensorCast)
       return failure();
-    if (!tensorCast.getSource().getType().isa<RankedTensorType>())
+    if (!llvm::isa<RankedTensorType>(tensorCast.getSource().getType()))
       return failure();
     rewriter.replaceOpWithNewOp<tensor::ExtractOp>(
         extract, tensorCast.getSource(), extract.getIndices());
     return success();
   }
 };
 
 } // namespace
 
 void ExtractOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   setNameFn(getResult(), "extracted");
 }
 
 LogicalResult ExtractOp::verify() {
   // Verify the # indices match if we have a ranked type.
-  auto tensorType = getTensor().getType().cast<RankedTensorType>();
+  auto tensorType = llvm::cast<RankedTensorType>(getTensor().getType());
   if (tensorType.getRank() != static_cast<int64_t>(getIndices().size()))
     return emitOpError("incorrect number of indices for extract_element");
   return success();
 }
 
 OpFoldResult ExtractOp::fold(FoldAdaptor adaptor) {
   // If this is a splat elements attribute, simply return the value. All of
   // the elements of a splat attribute are the same.
   if (Attribute tensor = adaptor.getTensor())
-    if (auto splatTensor = tensor.dyn_cast<SplatElementsAttr>())
+    if (auto splatTensor = llvm::dyn_cast<SplatElementsAttr>(tensor))
       return splatTensor.getSplatValue<Attribute>();
 
   // Collect the constant indices into the tensor.
   SmallVector<uint64_t, 8> indices;
   for (Attribute indice : adaptor.getIndices()) {
-    if (!indice || !indice.isa<IntegerAttr>())
+    if (!indice || !llvm::isa<IntegerAttr>(indice))
       return {};
-    indices.push_back(indice.cast<IntegerAttr>().getInt());
+    indices.push_back(llvm::cast<IntegerAttr>(indice).getInt());
   }
 
   // Fold extract(from_elements(...)).
   if (auto fromElementsOp = getTensor().getDefiningOp<FromElementsOp>()) {
-    auto tensorType = fromElementsOp.getType().cast<RankedTensorType>();
+    auto tensorType = llvm::cast<RankedTensorType>(fromElementsOp.getType());
     auto rank = tensorType.getRank();
     assert(static_cast<int64_t>(indices.size()) == tensorType.getRank() &&
            "rank mismatch");
     int flatIndex = 0;
     int stride = 1;
     for (int i = rank - 1; i >= 0; --i) {
       if (i < rank - 1)
         stride *= tensorType.getDimSize(i);
       flatIndex += indices[i] * stride;
     }
     // Prevent out of bounds accesses. This can happen in invalid code that
     // will never execute.
     if (static_cast<int>(fromElementsOp.getElements().size()) <= flatIndex ||
         flatIndex < 0)
       return {};
     return fromElementsOp.getElements()[flatIndex];
   }
 
   // If this is an elements attribute, query the value at the given indices.
   if (Attribute tensor = adaptor.getTensor()) {
-    auto elementsAttr = tensor.dyn_cast<ElementsAttr>();
+    auto elementsAttr = llvm::dyn_cast<ElementsAttr>(tensor);
     if (elementsAttr && elementsAttr.isValidIndex(indices))
       return elementsAttr.getValues<Attribute>()[indices];
   }
 
   return {};
 }
 
 void ExtractOp::getCanonicalizationPatterns(RewritePatternSet &results,

 
 void InsertOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   setNameFn(getResult(), "inserted");
 }
 
 LogicalResult InsertOp::verify() {
   // Verify the # indices match if we have a ranked type.
-  auto destType = getDest().getType().cast<RankedTensorType>();
+  auto destType = llvm::cast<RankedTensorType>(getDest().getType());
   if (destType.getRank() != static_cast<int64_t>(getIndices().size()))
     return emitOpError("incorrect number of indices");
   return success();
 }
 
 OpFoldResult InsertOp::fold(FoldAdaptor adaptor) {
   Attribute scalar = adaptor.getScalar();
   Attribute dest = adaptor.getDest();
   if (scalar && dest)
-    if (auto splatDest = dest.dyn_cast<SplatElementsAttr>())
+    if (auto splatDest = llvm::dyn_cast<SplatElementsAttr>(dest))
       if (scalar == splatDest.getSplatValue<Attribute>())
         return dest;
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // GenerateOp
 //===----------------------------------------------------------------------===//
for (auto dim : llvm::seq<int64_t>(0, getType().getRank())) {
     }
   }
   return success();
 }
 
 LogicalResult GenerateOp::verify() {
   // Ensure that the tensor type has as many dynamic dimensions as are
   // specified by the operands.
-  RankedTensorType resultTy = getType().cast<RankedTensorType>();
+  RankedTensorType resultTy = llvm::cast<RankedTensorType>(getType());
   if (getNumOperands() != resultTy.getNumDynamicDims())
     return emitError("must have as many index operands as dynamic extents "
                      "in the result type");
 
   return success();
 }
 
 LogicalResult GenerateOp::verifyRegions() {
-  RankedTensorType resultTy = getType().cast<RankedTensorType>();
+  RankedTensorType resultTy = llvm::cast<RankedTensorType>(getType());
   // Ensure that region arguments span the index space.
   if (!llvm::all_of(getBody().getArgumentTypes(),
                     [](Type ty) { return ty.isIndex(); }))
     return emitError("all body arguments must be index");
   if (getBody().getNumArguments() != resultTy.getRank())
     return emitError("must have one body argument per input dimension");
 
   // Ensure that the region yields an element of the right type.
void GenerateOp::build(
     OpBuilder &b, OperationState &result, Type resultTy,
     ValueRange dynamicExtents,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuilder) {
   build(b, result, resultTy, dynamicExtents);
 
   // Build and populate body.
   OpBuilder::InsertionGuard guard(b);
   Region *bodyRegion = result.regions.front().get();
-  auto rank = resultTy.cast<RankedTensorType>().getRank();
+  auto rank = llvm::cast<RankedTensorType>(resultTy).getRank();
   SmallVector<Type, 2> argumentTypes(rank, b.getIndexType());
   SmallVector<Location, 2> argumentLocs(rank, result.location);
   Block *bodyBlock =
       b.createBlock(bodyRegion, bodyRegion->end(), argumentTypes, argumentLocs);
   bodyBuilder(b, result.location, bodyBlock->getArguments());
 }
 
 namespace {
 
 /// Canonicalizes tensor.generate operations with a constant
 /// operand into the equivalent operation with the operand expressed in the
 /// result type, instead. We also insert a type cast to make sure that the
 /// resulting IR is still well-typed.
 struct StaticTensorGenerate : public OpRewritePattern<GenerateOp> {
   using OpRewritePattern<GenerateOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(GenerateOp tensorFromElements,
                                 PatternRewriter &rewriter) const final {
     auto resultType =
-        tensorFromElements.getResult().getType().cast<RankedTensorType>();
+        llvm::cast<RankedTensorType>(tensorFromElements.getResult().getType());
 
     if (resultType.hasStaticShape())
       return failure();
 
     SmallVector<Value, 4> newOperands;
     SmallVector<int64_t, 4> newShape;
     auto operandsIt = tensorFromElements.getDynamicExtents().begin();
 

 
 void RankOp::getAsmResultNames(function_ref<void(Value, StringRef)> setNameFn) {
   setNameFn(getResult(), "rank");
 }
 
 OpFoldResult RankOp::fold(FoldAdaptor adaptor) {
   // Constant fold rank when the rank of the operand is known.
   auto type = getOperand().getType();
-  auto shapedType = type.dyn_cast<ShapedType>();
+  auto shapedType = llvm::dyn_cast<ShapedType>(type);
   if (shapedType && shapedType.hasRank())
     return IntegerAttr::get(IndexType::get(getContext()), shapedType.getRank());
   return IntegerAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
 
 void ReshapeOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   setNameFn(getResult(), "reshape");
 }
 
 static int64_t getNumElements(ShapedType type) {
   int64_t numElements = 1;
   for (auto dim : type.getShape())
     numElements *= dim;
   return numElements;
 }
 
 LogicalResult ReshapeOp::verify() {
-  TensorType operandType = getSource().getType().cast<TensorType>();
-  TensorType resultType = getResult().getType().cast<TensorType>();
+  TensorType operandType = llvm::cast<TensorType>(getSource().getType());
+  TensorType resultType = llvm::cast<TensorType>(getResult().getType());
 
   if (operandType.getElementType() != resultType.getElementType())
     return emitOpError("element types of source and destination tensor "
                        "types should be the same");
 
   int64_t shapeSize =
-      getShape().getType().cast<RankedTensorType>().getDimSize(0);
-  auto resultRankedType = resultType.dyn_cast<RankedTensorType>();
-  auto operandRankedType = operandType.dyn_cast<RankedTensorType>();
+      llvm::cast<RankedTensorType>(getShape().getType()).getDimSize(0);
+  auto resultRankedType = llvm::dyn_cast<RankedTensorType>(resultType);
+  auto operandRankedType = llvm::dyn_cast<RankedTensorType>(operandType);
 
   if (resultRankedType) {
     if (operandRankedType && resultRankedType.hasStaticShape() &&
         operandRankedType.hasStaticShape()) {
       if (getNumElements(operandRankedType) != getNumElements(resultRankedType))
         return emitOpError("source and destination tensor should have the "
                            "same number of elements");
     }
CollapseShapeOp::inferCollapsedType(RankedTensorType type,
 
   return RankedTensorType::get(newShape, type.getElementType());
 }
 
 void CollapseShapeOp::build(OpBuilder &b, OperationState &result, Value src,
                             ArrayRef<ReassociationIndices> reassociation,
                             ArrayRef<NamedAttribute> attrs) {
   auto resultType = inferCollapsedType(
-      src.getType().cast<RankedTensorType>(),
+      llvm::cast<RankedTensorType>(src.getType()),
       getSymbolLessAffineMaps(
           convertReassociationIndicesToExprs(b.getContext(), reassociation)));
   build(b, result, resultType, src, attrs);
   result.addAttribute(getReassociationAttrStrName(),
                       getReassociationIndicesAttribute(b, reassociation));
 }
 
 template <typename TensorReshapeOp, bool isExpansion = std::is_same<
struct FoldReshapeWithFromElements : OpRewritePattern<TensorReshapeOp> {
   using OpRewritePattern<TensorReshapeOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(TensorReshapeOp reshapeOp,
                                 PatternRewriter &rewriter) const override {
     auto fromElements =
         reshapeOp.getSrc().template getDefiningOp<FromElementsOp>();
     if (!fromElements)
       return failure();
 
-    auto shapedTy = reshapeOp.getType().template cast<ShapedType>();
+    auto shapedTy = llvm::cast<ShapedType>(reshapeOp.getType());
 
     if (!shapedTy.hasStaticShape())
       return failure();
 
     rewriter.replaceOpWithNewOp<FromElementsOp>(reshapeOp, reshapeOp.getType(),
                                                 fromElements.getElements());
     return success();
   }
 };
 
 // Fold CastOp into CollapseShapeOp when adding static information.
 struct FoldCollapseOfCastOp : public OpRewritePattern<CollapseShapeOp> {
   using OpRewritePattern<CollapseShapeOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(CollapseShapeOp collapseShapeOp,
                                 PatternRewriter &rewriter) const override {
     auto castOp = collapseShapeOp.getSrc().getDefiningOp<tensor::CastOp>();
     if (!tensor::canFoldIntoConsumerOp(castOp))
       return failure();
 
     RankedTensorType srcType =
-        castOp.getSource().getType().cast<RankedTensorType>();
+        llvm::cast<RankedTensorType>(castOp.getSource().getType());
     RankedTensorType newResultType = CollapseShapeOp::inferCollapsedType(
         srcType, collapseShapeOp.getReassociationMaps());
 
     if (newResultType == collapseShapeOp.getResultType()) {
       rewriter.updateRootInPlace(collapseShapeOp, [&]() {
         collapseShapeOp.getSrcMutable().assign(castOp.getSource());
       });
     } else {

 ///   e.g. 1x6x1 can rank-reduce to either 1x6 or 6x1 2-D tensors.
 ///
 /// To disambiguate, this function always drops the first 1 sizes occurrences.
 RankedTensorType ExtractSliceOp::inferCanonicalRankReducedResultType(
     unsigned desiredResultRank, RankedTensorType sourceRankedTensorType,
     ArrayRef<int64_t> offsets, ArrayRef<int64_t> sizes,
     ArrayRef<int64_t> strides) {
   // Type inferred in the absence of rank-reducing behavior.
-  auto inferredType =
-      inferResultType(sourceRankedTensorType, offsets, sizes, strides)
-          .cast<RankedTensorType>();
+  auto inferredType = llvm::cast<RankedTensorType>(
+      inferResultType(sourceRankedTensorType, offsets, sizes, strides));
   int rankDiff = inferredType.getRank() - desiredResultRank;
   if (rankDiff > 0) {
     auto shape = inferredType.getShape();
     llvm::SmallBitVector dimsToProject =
         getPositionsOfShapeOne(rankDiff, shape);
     SmallVector<int64_t> projectedShape;
     // Best effort rank-reducing: drop 1s in order.
     for (unsigned pos = 0, e = shape.size(); pos < e; ++pos)
void ExtractSliceOp::build(OpBuilder &b, OperationState &result,
                            ArrayRef<OpFoldResult> sizes,
                            ArrayRef<OpFoldResult> strides,
                            ArrayRef<NamedAttribute> attrs) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
   dispatchIndexOpFoldResults(offsets, dynamicOffsets, staticOffsets);
   dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes);
   dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides);
-  auto sourceRankedTensorType = source.getType().cast<RankedTensorType>();
+  auto sourceRankedTensorType = llvm::cast<RankedTensorType>(source.getType());
   // Structuring implementation this way avoids duplication between builders.
   if (!resultType) {
-    resultType =
-        ExtractSliceOp::inferResultType(sourceRankedTensorType, staticOffsets,
-                                        staticSizes, staticStrides)
-            .cast<RankedTensorType>();
+    resultType = llvm::cast<RankedTensorType>(ExtractSliceOp::inferResultType(
+        sourceRankedTensorType, staticOffsets, staticSizes, staticStrides));
   }
   build(b, result, resultType, source, dynamicOffsets, dynamicSizes,
         dynamicStrides, b.getDenseI64ArrayAttr(staticOffsets),
         b.getDenseI64ArrayAttr(staticSizes),
         b.getDenseI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 

 
 llvm::SmallBitVector ExtractSliceOp::getDroppedDims() {
   return ::getDroppedDims(getType().getShape(), getMixedSizes());
 }
 
 FailureOr<Value>
 ExtractSliceOp::rankReduceIfNeeded(OpBuilder &b, Location loc, Value value,
                                    ArrayRef<int64_t> desiredShape) {
-  auto sourceTensorType = value.getType().dyn_cast<RankedTensorType>();
+  auto sourceTensorType = llvm::dyn_cast<RankedTensorType>(value.getType());
   assert(sourceTensorType && "not a ranked tensor type");
   auto sourceShape = sourceTensorType.getShape();
   if (sourceShape.equals(desiredShape))
     return value;
   auto maybeRankReductionMask =
       mlir::computeRankReductionMask(sourceShape, desiredShape);
   if (!maybeRankReductionMask)
     return failure();
LogicalResult matchAndRewrite(ExtractSliceOp op,
     if (!matchPattern(op.getSource(), m_Constant(&attr)))
       return failure();
 
     // A constant splat is handled by fold().
     if (attr.isSplat())
       return failure();
 
     // Dynamic result shape is not supported.
-    auto sourceType = op.getSource().getType().cast<ShapedType>();
-    auto resultType = op.getResult().getType().cast<ShapedType>();
+    auto sourceType = llvm::cast<ShapedType>(op.getSource().getType());
+    auto resultType = llvm::cast<ShapedType>(op.getResult().getType());
     if (!sourceType.hasStaticShape() || !resultType.hasStaticShape())
       return failure();
 
     // Customized control over the folding.
     if (!controlFn(op))
       return failure();
 
     int64_t count = sourceType.getNumElements();
LogicalResult matchAndRewrite(ExtractSliceOp op,
     for (int64_t v : shape) {
       count = count / v;
       counts.push_back(count);
     }
 
     // New attribute constructed by the sliced values.
     DenseElementsAttr newAttr;
 
-    if (auto elems = attr.dyn_cast<DenseIntElementsAttr>()) {
+    if (auto elems = llvm::dyn_cast<DenseIntElementsAttr>(attr)) {
       SmallVector<APInt> outValues;
       outValues.reserve(sourceType.getNumElements());
       sliceElements<DenseElementsAttr::IntElementIterator, APInt>(
           elems.begin(), counts, offsets, sizes, strides, &outValues);
       newAttr = DenseElementsAttr::get(resultType, outValues);
-    } else if (auto elems = attr.dyn_cast<DenseFPElementsAttr>()) {
+    } else if (auto elems = llvm::dyn_cast<DenseFPElementsAttr>(attr)) {
       SmallVector<APFloat> outValues;
       outValues.reserve(sourceType.getNumElements());
       sliceElements<DenseElementsAttr::FloatElementIterator, APFloat>(
           elems.begin(), counts, offsets, sizes, strides, &outValues);
       newAttr = DenseElementsAttr::get(resultType, outValues);
     }
 
     if (newAttr) {
if (insertOp && insertOp.getSource().getType() == extractOp.getType() &&
       insertOp.isSameAs(extractOp, isSame))
     return insertOp.getSource();
 
   return {};
 }
 
 OpFoldResult ExtractSliceOp::fold(FoldAdaptor adaptor) {
   if (auto splat = adaptor.getSource().dyn_cast_or_null<SplatElementsAttr>()) {
-    auto resultType = getResult().getType().cast<ShapedType>();
+    auto resultType = llvm::cast<ShapedType>(getResult().getType());
     if (resultType.hasStaticShape())
       return splat.resizeSplat(resultType);
   }
   if (getSourceType() == getType() &&
       succeeded(foldIdentityOffsetSizeAndStrideOpInterface(*this, getType())))
     return this->getSource();
   if (Value slice = foldExtractAfterInsertSlice(*this))
     return slice;
 
   return OpFoldResult();
 }
 
 Value mlir::tensor::createCanonicalRankReducingExtractSliceOp(
     OpBuilder &b, Location loc, Value tensor, RankedTensorType targetType) {
-  auto rankedTensorType = tensor.getType().cast<RankedTensorType>();
+  auto rankedTensorType = llvm::cast<RankedTensorType>(tensor.getType());
   unsigned rank = rankedTensorType.getRank();
   SmallVector<OpFoldResult> offsets(rank, b.getIndexAttr(0));
   SmallVector<OpFoldResult> sizes = getMixedSizes(b, loc, tensor);
   SmallVector<OpFoldResult> strides(rank, b.getIndexAttr(1));
   return b.createOrFold<tensor::ExtractSliceOp>(loc, targetType, tensor,
                                                 offsets, sizes, strides);
 }
 
LogicalResult matchAndRewrite(InsertOpTy insertSliceOp,
     std::optional<Value> destCastSource =
         getSourceOfCastOp(insertSliceOp.getDest());
     if (!sourceCastSource && !destCastSource)
       return failure();
 
     auto src =
         (sourceCastSource ? *sourceCastSource : insertSliceOp.getSource());
     auto dst = (destCastSource ? *destCastSource : insertSliceOp.getDest());
-    auto srcType = src.getType().template dyn_cast<RankedTensorType>();
-    auto dstType = dst.getType().template dyn_cast<RankedTensorType>();
+    auto srcType = llvm::dyn_cast<RankedTensorType>(src.getType());
+    auto dstType = llvm::dyn_cast<RankedTensorType>(dst.getType());
     if (!srcType || !dstType)
       return failure();
     if (verifyInsertSliceOp(srcType, dstType, insertSliceOp.getStaticOffsets(),
                             insertSliceOp.getStaticSizes(),
                             insertSliceOp.getStaticStrides()) !=
         SliceVerificationResult::Success)
       return failure();
 
results.add<InsertSliceOpConstantArgumentFolder<InsertSliceOp>,
               InsertSliceOpCastFolder<InsertSliceOp>,
               InsertSliceOpSourceCastInserter<InsertSliceOp>>(context);
 }
 
 Value mlir::tensor::createCanonicalRankReducingInsertSliceOp(OpBuilder &b,
                                                              Location loc,
                                                              Value tensor,
                                                              Value dest) {
-  auto rankedTensorType = dest.getType().cast<RankedTensorType>();
+  auto rankedTensorType = llvm::cast<RankedTensorType>(dest.getType());
   unsigned rank = rankedTensorType.getRank();
   SmallVector<OpFoldResult> offsets(rank, b.getIndexAttr(0));
   SmallVector<OpFoldResult> sizes = getMixedSizes(b, loc, dest);
   SmallVector<OpFoldResult> strides(rank, b.getIndexAttr(1));
   return b.createOrFold<tensor::InsertSliceOp>(loc, tensor, dest, offsets,
                                                sizes, strides);
 }
 
parseInferType(OpAsmParser &parser,
                std::optional<OpAsmParser::UnresolvedOperand> optOperand,
                Type &typeToInfer, Type typeToInferFrom) {
   if (optOperand)
     typeToInfer = typeToInferFrom;
   return success();
 }
 
 LogicalResult PadOp::verify() {
-  auto sourceType = getSource().getType().cast<RankedTensorType>();
-  auto resultType = getResult().getType().cast<RankedTensorType>();
+  auto sourceType = llvm::cast<RankedTensorType>(getSource().getType());
+  auto resultType = llvm::cast<RankedTensorType>(getResult().getType());
   auto expectedType =
       PadOp::inferResultType(sourceType, getStaticLow(), getStaticHigh());
   if (!expectedType) {
     return emitError("failed to infer expectedType from sourceType ")
            << sourceType << ", specified resultType is " << resultType;
   }
   if (resultType.getRank() != expectedType.getRank()) {
     return emitError("specified type ")
return emitError("specified type ")
            << expectedType;
   }
 
   return success();
 }
 
 LogicalResult PadOp::verifyRegions() {
   auto &region = getRegion();
-  unsigned rank = getResult().getType().cast<RankedTensorType>().getRank();
+  unsigned rank = llvm::cast<RankedTensorType>(getResult().getType()).getRank();
   Block &block = region.front();
   if (block.getNumArguments() != rank)
     return emitError("expected the block to have ") << rank << " arguments";
 
   // Note: the number and type of yield values are checked in the YieldOp.
   for (const auto &en : llvm::enumerate(block.getArgumentTypes())) {
     if (!en.value().isIndex())
       return emitOpError("expected block argument ")
              << (en.index() + 1) << " to be an index";
   }
 
   // Ensure that the region yields an element of the right type.
   auto yieldOp = llvm::cast<YieldOp>(block.getTerminator());
   if (yieldOp.getValue().getType() !=
-      getType().cast<ShapedType>().getElementType())
+      llvm::cast<ShapedType>(getType()).getElementType())
     return emitOpError("expected yield type to match shape element type");
 
   return success();
 }
 
 RankedTensorType PadOp::inferResultType(RankedTensorType sourceType,
                                         ArrayRef<int64_t> staticLow,
                                         ArrayRef<int64_t> staticHigh,
RankedTensorType PadOp::inferResultType(RankedTensorType sourceType,
 
   return RankedTensorType::get(inferredShape, sourceType.getElementType());
 }
 
 void PadOp::build(OpBuilder &b, OperationState &result, Type resultType,
                   Value source, ArrayRef<int64_t> staticLow,
                   ArrayRef<int64_t> staticHigh, ValueRange low, ValueRange high,
                   bool nofold, ArrayRef<NamedAttribute> attrs) {
-  auto sourceType = source.getType().cast<RankedTensorType>();
+  auto sourceType = llvm::cast<RankedTensorType>(source.getType());
   if (!resultType)
     resultType = inferResultType(sourceType, staticLow, staticHigh);
   build(b, result, resultType, source, low, high,
         b.getDenseI64ArrayAttr(staticLow), b.getDenseI64ArrayAttr(staticHigh),
         nofold ? b.getUnitAttr() : UnitAttr());
   result.addAttributes(attrs);
 }
 
 void PadOp::build(OpBuilder &b, OperationState &result, Type resultType,
                   Value source, ValueRange low, ValueRange high, bool nofold,
                   ArrayRef<NamedAttribute> attrs) {
-  auto sourceType = source.getType().cast<RankedTensorType>();
+  auto sourceType = llvm::cast<RankedTensorType>(source.getType());
   unsigned rank = sourceType.getRank();
   SmallVector<int64_t, 4> staticVector(rank, ShapedType::kDynamic);
   build(b, result, resultType, source, staticVector, staticVector, low, high,
         nofold, attrs);
 }
 
 void PadOp::build(OpBuilder &b, OperationState &result, Type resultType,
                   Value source, ArrayRef<OpFoldResult> low,
                   ArrayRef<OpFoldResult> high, bool nofold,
                   ArrayRef<NamedAttribute> attrs) {
-  auto sourceType = source.getType().cast<RankedTensorType>();
+  auto sourceType = llvm::cast<RankedTensorType>(source.getType());
   SmallVector<Value, 4> dynamicLow, dynamicHigh;
   SmallVector<int64_t, 4> staticLow, staticHigh;
   // staticLow and staticHigh have full information of the padding config.
   // This will grow staticLow and staticHigh with 1 value. If the config is
   // dynamic (ie not a constant), dynamicLow and dynamicHigh will grow with 1
   // value as well.
   dispatchIndexOpFoldResults(low, dynamicLow, staticLow);
   dispatchIndexOpFoldResults(high, dynamicHigh, staticHigh);
   if (!resultType) {
     resultType = PadOp::inferResultType(sourceType, staticLow, staticHigh);
   }
-  assert(resultType.isa<RankedTensorType>());
+  assert(llvm::isa<RankedTensorType>(resultType));
   build(b, result, resultType, source, dynamicLow, dynamicHigh,
         b.getDenseI64ArrayAttr(staticLow), b.getDenseI64ArrayAttr(staticHigh),
         nofold ? b.getUnitAttr() : UnitAttr());
   result.addAttributes(attrs);
 }
 
 void PadOp::build(OpBuilder &b, OperationState &result, Type resultType,
                   Value source, ArrayRef<OpFoldResult> low,
                   ArrayRef<OpFoldResult> high, Value constantPadValue,
                   bool nofold, ArrayRef<NamedAttribute> attrs) {
   build(b, result, resultType, source, low, high, nofold, attrs);
 
   // Add a region and a block to yield the pad value.
   Region *region = result.regions[0].get();
-  int sourceRank = source.getType().cast<RankedTensorType>().getRank();
+  int sourceRank = llvm::cast<RankedTensorType>(source.getType()).getRank();
   SmallVector<Type> blockArgTypes(sourceRank, b.getIndexType());
   SmallVector<Location> blockArgLocs(sourceRank, result.location);
 
   // `builder.createBlock` changes the insertion point within the block. Create
   // a guard to reset the insertion point of the builder after it is destroyed.
   OpBuilder::InsertionGuard guard(b);
   b.createBlock(region, region->end(), blockArgTypes, blockArgLocs);
   b.create<tensor::YieldOp>(result.location, constantPadValue);
struct FoldSourceTensorCast : public OpRewritePattern<PadOp> {
 
   LogicalResult matchAndRewrite(PadOp padTensorOp,
                                 PatternRewriter &rewriter) const override {
     auto castOp = padTensorOp.getSource().getDefiningOp<tensor::CastOp>();
     if (!tensor::canFoldIntoConsumerOp(castOp))
       return failure();
 
     auto newResultType = PadOp::inferResultType(
-        castOp.getSource().getType().cast<RankedTensorType>(),
+        llvm::cast<RankedTensorType>(castOp.getSource().getType()),
         padTensorOp.getStaticLow(), padTensorOp.getStaticHigh(),
         padTensorOp.getResultType().getShape());
 
     if (newResultType == padTensorOp.getResultType()) {
       rewriter.updateRootInPlace(padTensorOp, [&]() {
         padTensorOp.getSourceMutable().assign(castOp.getSource());
       });
     } else {

 };
 
 struct FoldStaticPadding : public OpRewritePattern<PadOp> {
   using OpRewritePattern<PadOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(PadOp padTensorOp,
                                 PatternRewriter &rewriter) const override {
     Value input = padTensorOp.getSource();
-    if (!input.getType().isa<RankedTensorType>())
+    if (!llvm::isa<RankedTensorType>(input.getType()))
       return failure();
-    auto inputDims = input.getType().cast<RankedTensorType>().getShape();
+    auto inputDims = llvm::cast<RankedTensorType>(input.getType()).getShape();
     auto inputRank = inputDims.size();
 
     auto oldResultType =
         dyn_cast<RankedTensorType>(padTensorOp.getResult().getType());
     if (!oldResultType)
       return failure();
 
     auto outputDims = oldResultType.getShape();

 template <typename OpTy>
 static LogicalResult
 reifyResultShapesImpl(OpTy op, OpBuilder &builder,
                       ReifiedRankedShapedTypeDims &reifiedReturnShapes) {
   static_assert(llvm::is_one_of<OpTy, PackOp, UnPackOp>::value,
                 "applies to only pack or unpack operations");
   int64_t destRank = op.getDestRank();
   reifiedReturnShapes.resize(1, SmallVector<OpFoldResult>(destRank));
-  ShapedType resultType = op.getResult().getType().template cast<ShapedType>();
+  ShapedType resultType = llvm::cast<ShapedType>(op.getResult().getType());
   for (auto dim : llvm::seq<int64_t>(0, destRank)) {
     if (resultType.isDynamicDim(dim)) {
       reifiedReturnShapes[0][dim] =
           builder.createOrFold<tensor::DimOp>(op.getLoc(), op.getDest(), dim);
     } else {
       reifiedReturnShapes[0][dim] =
           builder.getIndexAttr(resultType.getDimSize(dim));
     }
Value PackOp::createDestinationTensor(OpBuilder &b, Location loc, Value source,
   AffineExpr dim0, dim1;
   bindDims(b.getContext(), dim0, dim1);
   auto ceilDiv = [&](OpFoldResult v1, OpFoldResult v2) -> OpFoldResult {
     return affine::makeComposedFoldedAffineApply(b, loc, dim0.ceilDiv(dim1),
                                                  {v1, v2});
   };
 
   SmallVector<OpFoldResult> mixedSizes;
-  for (auto [index, value] :
-       llvm::enumerate(source.getType().cast<RankedTensorType>().getShape())) {
+  for (auto [index, value] : llvm::enumerate(
+           llvm::cast<RankedTensorType>(source.getType()).getShape())) {
     if (ShapedType::isDynamic(value))
       mixedSizes.push_back(b.create<DimOp>(loc, source, index).getResult());
     else
       mixedSizes.push_back(b.getIndexAttr(value));
   }
   for (auto it : llvm::zip(innerDimsPos, innerTileSizes)) {
     int64_t dimPos = std::get<0>(it);
     OpFoldResult tileSize = std::get<1>(it);
     mixedSizes[dimPos] = ceilDiv(mixedSizes[dimPos], tileSize);
   }
   if (!outerDimsPerm.empty())
     applyPermutationToVector<OpFoldResult>(mixedSizes, outerDimsPerm);
 
   mixedSizes.append(innerTileSizes.begin(), innerTileSizes.end());
-  auto elemType = source.getType().cast<ShapedType>().getElementType();
+  auto elemType = llvm::cast<ShapedType>(source.getType()).getElementType();
   return b.create<tensor::EmptyOp>(loc, mixedSizes, elemType);
 }
 
 PackOp PackOp::createTransposedClone(OpBuilder &b, Location loc,
                                      ArrayRef<int64_t> innerPermutation,
                                      ArrayRef<int64_t> outerPermutation) {
   PackOrUnPackTransposeResult metadata = commonPermutationOfPackAndUnPackOp(
       *this, innerPermutation, outerPermutation);
static bool isLikePadUnPad(PackOrUnpackOp packOp,
   // ones are ones.
   return llvm::all_of(
       llvm::seq<int64_t>(0, packedRank - numPackedDims),
       [&packedShape](int64_t i) { return packedShape[i] == 1; });
 }
 
 bool PackOp::isLikePad() {
   auto packedTensorType =
-      (*this)->getResultTypes().front().cast<RankedTensorType>();
+      llvm::cast<RankedTensorType>((*this)->getResultTypes().front());
   return isLikePadUnPad(*this, packedTensorType);
 }
 
 //===----------------------------------------------------------------------===//
 // UnPackOp
 //===----------------------------------------------------------------------===//
 
 void UnPackOp::getAsmResultNames(
Value UnPackOp::createDestinationTensor(OpBuilder &b, Location loc,
                                         ArrayRef<int64_t> outerDimsPerm) {
   AffineExpr sym0, sym1;
   bindSymbols(b.getContext(), sym0, sym1);
   auto dimMul = [&](OpFoldResult v1, OpFoldResult v2) -> OpFoldResult {
     return affine::makeComposedFoldedAffineApply(b, loc, sym0 * sym1, {v1, v2});
   };
 
   SmallVector<OpFoldResult> mixedSizes;
-  auto srcType = source.getType().cast<RankedTensorType>();
+  auto srcType = llvm::cast<RankedTensorType>(source.getType());
   for (auto i :
        llvm::seq<unsigned>(0, srcType.getRank() - innerTileSizes.size())) {
     if (srcType.isDynamicDim(i))
       mixedSizes.push_back(b.create<DimOp>(loc, source, i).getResult());
     else
       mixedSizes.push_back(b.getIndexAttr(srcType.getDimSize(i)));
   }
   if (!outerDimsPerm.empty()) {
LogicalResult matchAndRewrite(DestinationStyleOpInterface op,
                                 PatternRewriter &rewriter) const override {
     // InsertSliceOp has its own logic about folding tensor.cast ops.
     if (isa<InsertSliceOp>(op.getOperation()))
       return failure();
 
     // If no operand comes from a tensor::CastOp and can be folded then fail.
     bool hasTensorCastOperand =
         llvm::any_of(op->getOpOperands(), [&](OpOperand &opOperand) {
-          if (opOperand.get().isa<BlockArgument>())
+          if (llvm::isa<BlockArgument>(opOperand.get()))
             return false;
           auto castOp = opOperand.get().getDefiningOp<tensor::CastOp>();
           return castOp && canFoldIntoConsumerOp(castOp);
         });
     if (!hasTensorCastOperand)
       return failure();
 
     SmallVector<Type, 4> newResultTypes;
     newResultTypes.reserve(op->getNumResults());
     SmallVector<Value, 4> newOperands;
     newOperands.reserve(op->getNumOperands());
     for (OpOperand &opOperand : op->getOpOperands()) {
       auto tensorCastOp = opOperand.get().getDefiningOp<tensor::CastOp>();
       bool fold = canFoldIntoConsumerOp(tensorCastOp);
       newOperands.push_back(fold ? tensorCastOp.getOperand() : opOperand.get());
       if (op.isDpsInit(&opOperand) &&
-          !newOperands.back().getType().isa<MemRefType>())
+          !llvm::isa<MemRefType>(newOperands.back().getType()))
         newResultTypes.push_back(newOperands.back().getType());
     }
 
     // Clone op.
     Operation *newOp = clone(rewriter, op, newResultTypes, newOperands);
     SmallVector<Value, 4> replacements;
     replacements.reserve(newOp->getNumResults());
     for (auto [oldResult, newResult] :

mlir/lib/Dialect/Tensor/IR/ValueBoundsOpInterfaceImpl.cpp

 
 struct CastOpInterface
     : public ValueBoundsOpInterface::ExternalModel<CastOpInterface, CastOp> {
   void populateBoundsForShapedValueDim(Operation *op, Value value, int64_t dim,
                                        ValueBoundsConstraintSet &cstr) const {
     auto castOp = cast<CastOp>(op);
     assert(value == castOp.getResult() && "invalid value");
 
-    if (castOp.getResult().getType().isa<RankedTensorType>() &&
-        castOp.getSource().getType().isa<RankedTensorType>()) {
+    if (llvm::isa<RankedTensorType>(castOp.getResult().getType()) &&
+        llvm::isa<RankedTensorType>(castOp.getSource().getType())) {
       cstr.bound(value)[dim] == cstr.getExpr(castOp.getSource(), dim);
     }
   }
 };
 
 struct DimOpInterface
     : public ValueBoundsOpInterface::ExternalModel<DimOpInterface, DimOp> {
   void populateBoundsForIndexValue(Operation *op, Value value,

 
 struct RankOpInterface
     : public ValueBoundsOpInterface::ExternalModel<RankOpInterface, RankOp> {
   void populateBoundsForIndexValue(Operation *op, Value value,
                                    ValueBoundsConstraintSet &cstr) const {
     auto rankOp = cast<RankOp>(op);
     assert(value == rankOp.getResult() && "invalid value");
 
-    auto tensorType = rankOp.getTensor().getType().dyn_cast<RankedTensorType>();
+    auto tensorType =
+        llvm::dyn_cast<RankedTensorType>(rankOp.getTensor().getType());
     if (!tensorType)
       return;
     cstr.bound(value) == tensorType.getRank();
   }
 };
 
 } // namespace
 } // namespace tensor

mlir/lib/Dialect/Tosa/IR/TosaCanonicalizations.cpp

 };
 
 struct ReshapeConstOptimization : public OpRewritePattern<tosa::ReshapeOp> {
   using OpRewritePattern<tosa::ReshapeOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::ReshapeOp op,
                                 PatternRewriter &rewriter) const override {
     Value input = op.getInput1();
-    ShapedType inputTy = input.getType().cast<ShapedType>();
-    ShapedType resultTy = op.getType().cast<ShapedType>();
+    ShapedType inputTy = llvm::cast<ShapedType>(input.getType());
+    ShapedType resultTy = llvm::cast<ShapedType>(op.getType());
 
     if (inputTy.getElementType() != resultTy.getElementType())
       return rewriter.notifyMatchFailure(op, "element type does not match.");
 
     // Check if input is constant
     DenseElementsAttr inputAttr;
     if (!matchPattern(input, m_Constant(&inputAttr)))
       return rewriter.notifyMatchFailure(op, "Non-constant input.");
 
     // Check if has >1 consumer and is not splat
     if (!input.hasOneUse() && !inputAttr.isSplat())
       return rewriter.notifyMatchFailure(op,
                                          "Used more than once or not-splat");
 
     // Build new const op with correct output shape
     DenseElementsAttr outputAttr = inputAttr.reshape(
-        inputAttr.getType().cast<ShapedType>().clone(op.getNewShape()));
+        llvm::cast<ShapedType>(inputAttr.getType()).clone(op.getNewShape()));
     rewriter.replaceOpWithNewOp<tosa::ConstOp>(op, resultTy, outputAttr);
     return success();
   }
 };
 
 void ReshapeOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                             MLIRContext *context) {
   results.add<ReshapeReshapeOptimization>(context);
LogicalResult matchAndRewrite(tosa::TransposeOp op,
     Value result = op.getResult();
     for (Operation *subop : result.getUsers()) {
       if (dyn_cast_or_null<tosa::TransposeOp>(subop))
         return rewriter.notifyMatchFailure(
             op, "Dest is used by transpose, can compose transposes");
     }
 
     auto input = op.getInput1();
-    auto inputTy = input.getType().cast<ShapedType>();
+    auto inputTy = llvm::cast<ShapedType>(input.getType());
     if (!inputTy.hasRank())
       return rewriter.notifyMatchFailure(op, "Unranked input.");
 
     int64_t numDynDims = 0;
     for (int i = 0; i < inputTy.getRank(); ++i)
       if (inputTy.isDynamicDim(i))
         numDynDims++;
 
struct MaterializePadValue : public OpRewritePattern<tosa::PadOp> {
   LogicalResult matchAndRewrite(tosa::PadOp op,
                                 PatternRewriter &rewriter) const override {
     if (op.getPadConst())
       return failure();
 
     auto input = op.getInput1();
     auto padding = op.getPadding();
 
-    ShapedType inputTy = input.getType().cast<ShapedType>();
+    ShapedType inputTy = llvm::cast<ShapedType>(input.getType());
     Type elementTy = inputTy.getElementType();
 
     Attribute constantAttr;
-    if (elementTy.isa<FloatType>()) {
+    if (llvm::isa<FloatType>(elementTy)) {
       constantAttr = rewriter.getFloatAttr(elementTy, 0.0);
-    } else if (elementTy.isa<IntegerType>() && !op.getQuantizationInfo()) {
+    } else if (llvm::isa<IntegerType>(elementTy) && !op.getQuantizationInfo()) {
       constantAttr = rewriter.getIntegerAttr(elementTy, 0);
-    } else if (elementTy.isa<IntegerType>() && op.getQuantizationInfo()) {
+    } else if (llvm::isa<IntegerType>(elementTy) && op.getQuantizationInfo()) {
       auto value = op.getQuantizationInfo()->getInputZp();
       constantAttr = rewriter.getIntegerAttr(elementTy, value);
     }
 
     if (!constantAttr) {
       return rewriter.notifyMatchFailure(
           op,
           "tosa.pad to linalg lowering encountered an unknown element type");

 
 struct MaxPool2dIsNoOp : public OpRewritePattern<tosa::MaxPool2dOp> {
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::MaxPool2dOp op,
                                 PatternRewriter &rewriter) const override {
     Value input = op.getInput();
     Value output = op.getOutput();
-    ShapedType inputType = input.getType().cast<ShapedType>();
-    ShapedType outputType = output.getType().cast<ShapedType>();
+    ShapedType inputType = llvm::cast<ShapedType>(input.getType());
+    ShapedType outputType = llvm::cast<ShapedType>(output.getType());
 
     if (!inputType.hasStaticShape() || !outputType.hasStaticShape()) {
       return failure();
     }
 
     // If the output and input shapes are 1x1, then this is a no op.
     ArrayRef<int64_t> outputShape = outputType.getShape();
     if (outputShape[1] != 1 || outputShape[2] != 1) {

 }
 
 struct ClampIsNoOp : public OpRewritePattern<tosa::ClampOp> {
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::ClampOp op,
                                 PatternRewriter &rewriter) const override {
     Value input = op.getInput();
-    auto inputType =
-        op.getInput().getType().template dyn_cast<RankedTensorType>();
+    auto inputType = llvm::dyn_cast<RankedTensorType>(op.getInput().getType());
     auto inputElementType = inputType.getElementType();
 
     if (!inputType.hasStaticShape()) {
       return failure();
     }
 
     if (inputElementType.isF32()) {
       auto minClamp = op.getMinFp();
if (inputElementType.isUnsignedInteger()) {
 
       if (minClamp <= intMin && maxClamp >= intMax) {
         rewriter.replaceOp(op, input);
         return success();
       }
       return failure();
     }
 
-    if (inputElementType.isa<IntegerType>()) {
+    if (llvm::isa<IntegerType>(inputElementType)) {
       int64_t minClamp = op.getMinInt();
       int64_t maxClamp = op.getMaxInt();
 
       int64_t intMin =
           APInt::getSignedMinValue(inputElementType.getIntOrFloatBitWidth())
               .getSExtValue();
       int64_t intMax =
           APInt::getSignedMaxValue(inputElementType.getIntOrFloatBitWidth())

 //===----------------------------------------------------------------------===//
 // Operator Folders.
 //===----------------------------------------------------------------------===//
 
 template <typename IntFolder, typename FloatFolder>
 DenseElementsAttr binaryFolder(DenseElementsAttr lhs, DenseElementsAttr rhs,
                                RankedTensorType returnTy) {
   if (rhs && lhs && rhs.isSplat() && lhs.isSplat()) {
-    auto lETy = lhs.getType().cast<ShapedType>().getElementType();
-    auto rETy = rhs.getType().cast<ShapedType>().getElementType();
+    auto lETy = llvm::cast<ShapedType>(lhs.getType()).getElementType();
+    auto rETy = llvm::cast<ShapedType>(rhs.getType()).getElementType();
     if (lETy != rETy)
       return {};
 
-    if (lETy.isa<IntegerType>()) {
+    if (llvm::isa<IntegerType>(lETy)) {
       APInt l = lhs.getSplatValue<APInt>();
       APInt r = rhs.getSplatValue<APInt>();
       auto result = IntFolder()(l, r);
       return DenseElementsAttr::get(returnTy, result);
     }
 
-    if (lETy.isa<FloatType>()) {
+    if (llvm::isa<FloatType>(lETy)) {
       APFloat l = lhs.getSplatValue<APFloat>();
       APFloat r = rhs.getSplatValue<APFloat>();
       auto result = FloatFolder()(l, r);
       return DenseElementsAttr::get(returnTy, result);
     }
   }
 
   return {};
 }
 
 static bool isSplatZero(Type elemType, DenseElementsAttr val) {
-  if (elemType.isa<FloatType>())
+  if (llvm::isa<FloatType>(elemType))
     return val && val.isSplat() && val.getSplatValue<APFloat>().isZero();
-  if (elemType.isa<IntegerType>())
+  if (llvm::isa<IntegerType>(elemType))
     return val && val.isSplat() && val.getSplatValue<APInt>().isZero();
   return false;
 }
 
 static bool isSplatOne(Type elemType, DenseElementsAttr val, int64_t shift) {
-  if (elemType.isa<FloatType>())
+  if (llvm::isa<FloatType>(elemType))
     return val && val.isSplat() &&
            val.getSplatValue<APFloat>().isExactlyValue(1.0);
-  if (elemType.isa<IntegerType>()) {
+  if (llvm::isa<IntegerType>(elemType)) {
     const int64_t shifted = 1LL << shift;
     return val && val.isSplat() &&
            val.getSplatValue<APInt>().getSExtValue() == shifted;
   }
   return false;
 }
 
 OpFoldResult AddOp::fold(FoldAdaptor adaptor) {
-  auto lhsTy = getInput1().getType().dyn_cast<RankedTensorType>();
-  auto rhsTy = getInput2().getType().dyn_cast<RankedTensorType>();
-  auto resultTy = getType().dyn_cast<RankedTensorType>();
+  auto lhsTy = llvm::dyn_cast<RankedTensorType>(getInput1().getType());
+  auto rhsTy = llvm::dyn_cast<RankedTensorType>(getInput2().getType());
+  auto resultTy = llvm::dyn_cast<RankedTensorType>(getType());
   if (!lhsTy || !rhsTy || !resultTy)
     return {};
 
   auto resultETy = resultTy.getElementType();
   auto lhsAttr = adaptor.getInput1().dyn_cast_or_null<DenseElementsAttr>();
   auto rhsAttr = adaptor.getInput2().dyn_cast_or_null<DenseElementsAttr>();
 
   if (lhsTy == resultTy && isSplatZero(resultETy, rhsAttr))
     return getInput1();
   if (rhsTy == resultTy && isSplatZero(resultETy, lhsAttr))
     return getInput2();
 
   if (!lhsAttr || !rhsAttr)
     return {};
 
   return binaryFolder<std::plus<APInt>, std::plus<APFloat>>(lhsAttr, rhsAttr,
                                                             resultTy);
 }
 
 OpFoldResult DivOp::fold(FoldAdaptor adaptor) {
-  auto lhsTy = getInput1().getType().dyn_cast<RankedTensorType>();
-  auto rhsTy = getInput2().getType().dyn_cast<RankedTensorType>();
-  auto resultTy = getType().dyn_cast<RankedTensorType>();
+  auto lhsTy = llvm::dyn_cast<RankedTensorType>(getInput1().getType());
+  auto rhsTy = llvm::dyn_cast<RankedTensorType>(getInput2().getType());
+  auto resultTy = llvm::dyn_cast<RankedTensorType>(getType());
   if (!lhsTy || !rhsTy || !resultTy)
     return {};
   if (lhsTy != rhsTy)
     return {};
 
   auto resultETy = resultTy.getElementType();
   auto lhsAttr = adaptor.getInput1().dyn_cast_or_null<DenseElementsAttr>();
   auto rhsAttr = adaptor.getInput2().dyn_cast_or_null<DenseElementsAttr>();
   if (lhsAttr && lhsAttr.isSplat()) {
-    if (resultETy.isa<IntegerType>() && lhsAttr.getSplatValue<APInt>().isZero())
+    if (llvm::isa<IntegerType>(resultETy) &&
+        lhsAttr.getSplatValue<APInt>().isZero())
       return lhsAttr;
   }
 
   if (rhsAttr && rhsAttr.isSplat()) {
-    if (resultETy.isa<IntegerType>() && rhsAttr.getSplatValue<APInt>().isOne())
+    if (llvm::isa<IntegerType>(resultETy) &&
+        rhsAttr.getSplatValue<APInt>().isOne())
       return getInput1();
   }
 
   if (rhsAttr && lhsAttr && rhsAttr.isSplat() && lhsAttr.isSplat()) {
-    if (resultETy.isa<IntegerType>()) {
+    if (llvm::isa<IntegerType>(resultETy)) {
       APInt l = lhsAttr.getSplatValue<APInt>();
       APInt r = rhsAttr.getSplatValue<APInt>();
       APInt result = l.sdiv(r);
       return DenseElementsAttr::get(resultTy, result);
     }
   }
 
   return {};
 }
 
 namespace {
 DenseElementsAttr mulBinaryFolder(DenseElementsAttr lhs, DenseElementsAttr rhs,
                                   RankedTensorType ty, int32_t shift) {
   if (rhs && lhs && rhs.isSplat() && lhs.isSplat()) {
-    if (ty.getElementType().isa<IntegerType>()) {
+    if (llvm::isa<IntegerType>(ty.getElementType())) {
       APInt l = lhs.getSplatValue<APInt>();
       APInt r = rhs.getSplatValue<APInt>();
 
       if (shift == 0) {
         return DenseElementsAttr::get(ty, l * r);
       }
 
       auto bitwidth = ty.getElementType().getIntOrFloatBitWidth();
       l = l.sext(bitwidth * 2);
       r = r.sext(bitwidth * 2);
       auto result = l * r;
       result.lshrInPlace(shift);
       result = result.trunc(bitwidth);
       return DenseElementsAttr::get(ty, result);
     }
 
-    if (ty.getElementType().isa<FloatType>()) {
+    if (llvm::isa<FloatType>(ty.getElementType())) {
       APFloat l = lhs.getSplatValue<APFloat>();
       APFloat r = rhs.getSplatValue<APFloat>();
       APFloat result = l * r;
       return DenseElementsAttr::get(ty, result);
     }
   }
 
   return {};
 }
 } // namespace
 
 OpFoldResult MulOp::fold(FoldAdaptor adaptor) {
   auto lhs = getInput1();
   auto rhs = getInput2();
-  auto lhsTy = lhs.getType().dyn_cast<RankedTensorType>();
-  auto rhsTy = rhs.getType().dyn_cast<RankedTensorType>();
-  auto resultTy = getType().dyn_cast<RankedTensorType>();
+  auto lhsTy = llvm::dyn_cast<RankedTensorType>(lhs.getType());
+  auto rhsTy = llvm::dyn_cast<RankedTensorType>(rhs.getType());
+  auto resultTy = llvm::dyn_cast<RankedTensorType>(getType());
   if (!lhsTy || !rhsTy || !resultTy)
     return {};
 
   auto resultETy = resultTy.getElementType();
   auto lhsAttr = adaptor.getInput1().dyn_cast_or_null<DenseElementsAttr>();
   auto rhsAttr = adaptor.getInput2().dyn_cast_or_null<DenseElementsAttr>();
 
-  const int64_t shift = resultETy.isa<IntegerType>() ? getShift() : 0;
+  const int64_t shift = llvm::isa<IntegerType>(resultETy) ? getShift() : 0;
   if (rhsTy == resultTy) {
     if (isSplatZero(resultETy, lhsAttr))
       return lhsAttr;
     if (isSplatOne(resultETy, lhsAttr, shift))
       return rhs;
   }
   if (lhsTy == resultTy) {
     if (isSplatZero(resultETy, rhsAttr))
       return rhsAttr;
     if (isSplatOne(resultETy, rhsAttr, shift))
       return lhs;
   }
 
   return mulBinaryFolder(lhsAttr, rhsAttr, resultTy, getShift());
 }
 
 OpFoldResult SubOp::fold(FoldAdaptor adaptor) {
-  auto lhsTy = getInput1().getType().dyn_cast<RankedTensorType>();
-  auto rhsTy = getInput2().getType().dyn_cast<RankedTensorType>();
-  auto resultTy = getType().dyn_cast<RankedTensorType>();
+  auto lhsTy = llvm::dyn_cast<RankedTensorType>(getInput1().getType());
+  auto rhsTy = llvm::dyn_cast<RankedTensorType>(getInput2().getType());
+  auto resultTy = llvm::dyn_cast<RankedTensorType>(getType());
   if (!lhsTy || !rhsTy || !resultTy)
     return {};
 
   auto resultETy = resultTy.getElementType();
   auto lhsAttr = adaptor.getInput1().dyn_cast_or_null<DenseElementsAttr>();
   auto rhsAttr = adaptor.getInput2().dyn_cast_or_null<DenseElementsAttr>();
 
   if (lhsTy == resultTy && isSplatZero(resultETy, rhsAttr))
struct APIntFoldGreaterEqual {
   APIntFoldGreaterEqual() = default;
   APInt operator()(const APInt &l, const APInt &r) {
     return APInt(1, l.sge(r));
   }
 };
 } // namespace
 
 OpFoldResult GreaterOp::fold(FoldAdaptor adaptor) {
-  auto resultTy = getType().dyn_cast<RankedTensorType>();
+  auto resultTy = llvm::dyn_cast<RankedTensorType>(getType());
   auto lhsAttr = adaptor.getInput1().dyn_cast_or_null<DenseElementsAttr>();
   auto rhsAttr = adaptor.getInput2().dyn_cast_or_null<DenseElementsAttr>();
 
   if (!lhsAttr || !rhsAttr)
     return {};
 
   return binaryFolder<APIntFoldGreater, ComparisonFold<std::greater<APFloat>>>(
       lhsAttr, rhsAttr, resultTy);
 }
 
 OpFoldResult GreaterEqualOp::fold(FoldAdaptor adaptor) {
-  auto resultTy = getType().dyn_cast<RankedTensorType>();
+  auto resultTy = llvm::dyn_cast<RankedTensorType>(getType());
   auto lhsAttr = adaptor.getInput1().dyn_cast_or_null<DenseElementsAttr>();
   auto rhsAttr = adaptor.getInput2().dyn_cast_or_null<DenseElementsAttr>();
 
   if (!lhsAttr || !rhsAttr)
     return {};
 
   return binaryFolder<APIntFoldGreaterEqual,
                       ComparisonFold<std::greater_equal<APFloat>>>(
       lhsAttr, rhsAttr, resultTy);
 }
 
 OpFoldResult EqualOp::fold(FoldAdaptor adaptor) {
-  auto resultTy = getType().dyn_cast<RankedTensorType>();
+  auto resultTy = llvm::dyn_cast<RankedTensorType>(getType());
   auto lhsAttr = adaptor.getInput1().dyn_cast_or_null<DenseElementsAttr>();
   auto rhsAttr = adaptor.getInput2().dyn_cast_or_null<DenseElementsAttr>();
   Value lhs = getInput1();
   Value rhs = getInput2();
-  auto lhsTy = lhs.getType().cast<ShapedType>();
+  auto lhsTy = llvm::cast<ShapedType>(lhs.getType());
 
   // If we are comparing an integer value to itself it is always true. We can
   // not do this with float due to float values.
-  if (lhsTy.getElementType().isa<IntegerType>() && resultTy &&
+  if (llvm::isa<IntegerType>(lhsTy.getElementType()) && resultTy &&
       resultTy.hasStaticShape() && lhs == rhs) {
     return DenseElementsAttr::get(resultTy, true);
   }
 
   if (!lhsAttr || !rhsAttr)
     return {};
 
   return binaryFolder<ComparisonFold<std::equal_to<APInt>>,
                       ComparisonFold<std::equal_to<APFloat>>>(lhsAttr, rhsAttr,
                                                               resultTy);
 }
 
 OpFoldResult CastOp::fold(FoldAdaptor adaptor) {
   if (getInput().getType() == getType())
     return getInput();
 
   auto operand = adaptor.getInput().dyn_cast_or_null<ElementsAttr>();
   if (!operand)
     return {};
 
-  auto inTy = getInput().getType().cast<ShapedType>();
-  auto outTy = getType().cast<ShapedType>();
+  auto inTy = llvm::cast<ShapedType>(getInput().getType());
+  auto outTy = llvm::cast<ShapedType>(getType());
   auto inETy = inTy.getElementType();
   auto outETy = outTy.getElementType();
 
   if (operand.isSplat()) {
-    if (inETy.isa<FloatType>() && outETy.isa<FloatType>()) {
+    if (llvm::isa<FloatType>(inETy) && llvm::isa<FloatType>(outETy)) {
       bool overflow;
       auto splatVal = operand.getSplatValue<APFloat>();
-      auto &semantics = outETy.cast<FloatType>().getFloatSemantics();
+      auto &semantics = llvm::cast<FloatType>(outETy).getFloatSemantics();
       splatVal.convert(semantics, llvm::RoundingMode::NearestTiesToEven,
                        &overflow);
       return SplatElementsAttr::get(outTy, splatVal);
     }
 
-    if (inETy.isa<IntegerType>() && outETy.isa<FloatType>()) {
-      auto unsign = inETy.cast<IntegerType>().isUnsignedInteger();
-      APFloat splatVal(outETy.cast<FloatType>().getFloatSemantics());
+    if (llvm::isa<IntegerType>(inETy) && llvm::isa<FloatType>(outETy)) {
+      auto unsign = llvm::cast<IntegerType>(inETy).isUnsignedInteger();
+      APFloat splatVal(llvm::cast<FloatType>(outETy).getFloatSemantics());
       splatVal.convertFromAPInt(operand.getSplatValue<APInt>(), !unsign,
                                 llvm::RoundingMode::NearestTiesToEven);
       return SplatElementsAttr::get(outTy, splatVal);
     }
 
-    if (inETy.isa<FloatType>() && outETy.isa<IntegerType>()) {
-      auto unsign = outETy.cast<IntegerType>().isUnsignedInteger();
-      auto intVal =
-          APSInt(outETy.cast<IntegerType>().getIntOrFloatBitWidth(), unsign);
+    if (llvm::isa<FloatType>(inETy) && llvm::isa<IntegerType>(outETy)) {
+      auto unsign = llvm::cast<IntegerType>(outETy).isUnsignedInteger();
+      auto intVal = APSInt(
+          llvm::cast<IntegerType>(outETy).getIntOrFloatBitWidth(), unsign);
       auto floatVal = operand.getSplatValue<APFloat>();
       bool exact;
       floatVal.convertToInteger(intVal, llvm::RoundingMode::TowardZero, &exact);
       return SplatElementsAttr::get(outTy, intVal);
     }
 
-    if (inETy.isa<IntegerType>() && outETy.isa<IntegerType>()) {
-      auto unsignIn = inETy.cast<IntegerType>().isUnsignedInteger();
+    if (llvm::isa<IntegerType>(inETy) && llvm::isa<IntegerType>(outETy)) {
+      auto unsignIn = llvm::cast<IntegerType>(inETy).isUnsignedInteger();
       bool trunc =
           inETy.getIntOrFloatBitWidth() > outETy.getIntOrFloatBitWidth();
       auto intVal = operand.getSplatValue<APInt>();
       auto bitwidth = outETy.getIntOrFloatBitWidth();
 
       if (trunc) {
         intVal = intVal.trunc(bitwidth);
       } else if (unsignIn) {

 REDUCE_FOLDER(ReduceAnyOp)
 REDUCE_FOLDER(ReduceMaxOp)
 REDUCE_FOLDER(ReduceMinOp)
 REDUCE_FOLDER(ReduceProdOp)
 REDUCE_FOLDER(ReduceSumOp)
 #undef REDUCE_FOLDER
 
 OpFoldResult ReshapeOp::fold(FoldAdaptor adaptor) {
-  auto inputTy = getInput1().getType().dyn_cast<RankedTensorType>();
-  auto outputTy = getType().dyn_cast<RankedTensorType>();
+  auto inputTy = llvm::dyn_cast<RankedTensorType>(getInput1().getType());
+  auto outputTy = llvm::dyn_cast<RankedTensorType>(getType());
 
   if (!inputTy || !outputTy)
     return {};
 
   if (inputTy == outputTy)
     return getInput1();
 
   auto operand = adaptor.getInput1().dyn_cast_or_null<DenseElementsAttr>();
OpFoldResult ResizeOp::fold(FoldAdaptor adaptor) {
   }
 
   // There should be no border.
   if (border[0] != 0 || border[1] != 0) {
     return {};
   }
 
   auto input = getInput();
-  auto inputTy = input.getType().cast<RankedTensorType>();
-  auto resultTy = getType().cast<RankedTensorType>();
+  auto inputTy = llvm::cast<RankedTensorType>(input.getType());
+  auto resultTy = llvm::cast<RankedTensorType>(getType());
   if (inputTy != resultTy)
     return {};
 
   return input;
 }
 
 OpFoldResult ReverseOp::fold(FoldAdaptor adaptor) {
   auto operand = getInput();
-  auto operandTy = operand.getType().cast<ShapedType>();
+  auto operandTy = llvm::cast<ShapedType>(operand.getType());
   auto axis = getAxis();
   auto operandAttr = adaptor.getInput().dyn_cast_or_null<SplatElementsAttr>();
   if (operandAttr)
     return operandAttr;
 
   // If the dim-length is 1, tosa.reverse is a no-op.
   if (operandTy.hasRank() && operandTy.getDimSize(axis) == 1)
     return operand;
 
   return {};
 }
 
 OpFoldResult SliceOp::fold(FoldAdaptor adaptor) {
-  auto inputTy = getInput().getType().dyn_cast<RankedTensorType>();
-  auto outputTy = getType().dyn_cast<RankedTensorType>();
+  auto inputTy = llvm::dyn_cast<RankedTensorType>(getInput().getType());
+  auto outputTy = llvm::dyn_cast<RankedTensorType>(getType());
 
   if (!inputTy || !outputTy)
     return {};
 
   if (inputTy == outputTy && inputTy.hasStaticShape())
     return getInput();
 
   if (!adaptor.getInput())

 OpFoldResult TileOp::fold(FoldAdaptor adaptor) {
   bool allOnes = llvm::all_of(getMultiples(), [](int64_t v) { return v == 1; });
   if (allOnes && getInput1().getType() == getType())
     return getInput1();
   return {};
 }
 
 OpFoldResult TransposeOp::fold(FoldAdaptor adaptor) {
-  auto inputTy = getInput1().getType().cast<ShapedType>();
-  auto resultTy = getType().cast<ShapedType>();
+  auto inputTy = llvm::cast<ShapedType>(getInput1().getType());
+  auto resultTy = llvm::cast<ShapedType>(getType());
 
   // Transposing splat values just means reshaping.
   if (auto input = adaptor.getInput1().dyn_cast_or_null<DenseElementsAttr>()) {
     if (input.isSplat() && resultTy.hasStaticShape() &&
         inputTy.getElementType() == resultTy.getElementType())
       return input.reshape(resultTy);
   }
 

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

#include "mlir/Dialect/Tosa/IR/TosaAttributes.cpp.inc"
       >();
   addInterfaces<TosaInlinerInterface>();
 }
 
 Operation *TosaDialect::materializeConstant(OpBuilder &builder, Attribute value,
                                             Type type, Location loc) {
   // Tosa dialect constants only support ElementsAttr unlike standard dialect
   // constant which supports all attributes.
-  if (value.isa<ElementsAttr>())
-    return builder.create<tosa::ConstOp>(loc, type, value.cast<ElementsAttr>());
+  if (llvm::isa<ElementsAttr>(value))
+    return builder.create<tosa::ConstOp>(loc, type,
+                                         llvm::cast<ElementsAttr>(value));
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // TOSA Operator Verifiers.
 //===----------------------------------------------------------------------===//
 
 template <typename T> static LogicalResult verifyConvOp(T op) {
   // All TOSA conv ops have an input() and weight().
-  auto inputType =
-      op.getInput().getType().template dyn_cast<RankedTensorType>();
-  auto weightType =
-      op.getWeight().getType().template dyn_cast<RankedTensorType>();
+  auto inputType = llvm::dyn_cast<RankedTensorType>(op.getInput().getType());
+  auto weightType = llvm::dyn_cast<RankedTensorType>(op.getWeight().getType());
 
   // Must be ranked tensor types
   if (!inputType) {
     op.emitOpError("expect a ranked tensor for input, got ") << op.getInput();
     return failure();
   }
   if (!weightType) {
     op.emitOpError("expect a ranked tensor for weight, got ") << op.getWeight();
     return failure();
   }
 
   auto inputEType = inputType.getElementType();
   auto weightEType = weightType.getElementType();
 
-  bool inputIsQuant = !inputEType.template isa<FloatType>();
-  bool weightIsQuant = !weightEType.template isa<FloatType>();
+  bool inputIsQuant = !llvm::isa<FloatType>(inputEType);
+  bool weightIsQuant = !llvm::isa<FloatType>(weightEType);
 
   // Either both must be quantized or both unquantized.
   if (inputIsQuant != weightIsQuant) {
     op.emitOpError(
         "expect both input and weight to be float or not together, got ")
         << inputEType << " and " << weightEType;
     return failure();
   }
 
   // Quantized type must have constructed the quantizationattr, and unquantized
   // types should not have a quantizationattr.
   if ((inputIsQuant && !op.getQuantizationInfo()) ||
       (!inputIsQuant && op.getQuantizationInfo())) {
     op.emitOpError("quantizationattr is required for quantized type, and not "
                    "allowed for float type");
     return failure();
   }
 
   return success();
 }
 
 LogicalResult tosa::AvgPool2dOp::verify() {
-  auto inputETy = getInput().getType().cast<ShapedType>().getElementType();
-  auto resultETy = getType().cast<ShapedType>().getElementType();
+  auto inputETy = llvm::cast<ShapedType>(getInput().getType()).getElementType();
+  auto resultETy = llvm::cast<ShapedType>(getType()).getElementType();
 
-  if (auto quantType = inputETy.dyn_cast<mlir::quant::UniformQuantizedType>())
+  if (auto quantType =
+          llvm::dyn_cast<mlir::quant::UniformQuantizedType>(inputETy))
     inputETy = quantType.getStorageType();
 
-  if (auto quantType = resultETy.dyn_cast<mlir::quant::UniformQuantizedType>())
+  if (auto quantType =
+          llvm::dyn_cast<mlir::quant::UniformQuantizedType>(resultETy))
     resultETy = quantType.getStorageType();
 
   if (inputETy.isF32() && resultETy.isF32())
     return success();
   if (inputETy.isInteger(8) && resultETy.isInteger(8))
     return success();
   if (inputETy.isInteger(16) && resultETy.isInteger(16))
     return success();
static void buildMatMulOpWithQuantInfo(OpBuilder &builder,
                                        OperationState &result, Type outputType,
                                        Value a, Value b) {
   result.addOperands({a, b});
   auto quantAttr = ::buildMatMulOpQuantizationAttr(builder, a, b);
 
   if (quantAttr) {
     result.addAttribute("quantization_info", quantAttr);
 
-    auto inputType = a.getType().dyn_cast<ShapedType>();
+    auto inputType = llvm::dyn_cast<ShapedType>(a.getType());
     assert(inputType && "Input must be a shaped tensor type!");
 
-    auto inputQType = inputType.getElementType()
-                          .dyn_cast<mlir::quant::UniformQuantizedType>();
+    auto inputQType = llvm::dyn_cast<mlir::quant::UniformQuantizedType>(
+        inputType.getElementType());
     assert(inputQType && "Tensor must have quantized datatype!");
 
     unsigned inputBits = inputQType.getStorageTypeIntegralWidth();
 
-    auto outputShapedType = outputType.dyn_cast<ShapedType>();
+    auto outputShapedType = llvm::dyn_cast<ShapedType>(outputType);
     assert(outputShapedType && "Output must be a shaped type");
 
     IntegerType accElementType;
     if (inputBits == 16)
       accElementType = builder.getIntegerType(48);
     else
       accElementType = builder.getI32Type();
     auto accType = outputShapedType.clone(accElementType);

 }
 
 LogicalResult tosa::ArgMaxOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes,
     OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
-  IntegerAttr axis = attributes.get("axis").cast<IntegerAttr>();
+  IntegerAttr axis = llvm::cast<IntegerAttr>(attributes.get("axis"));
   int32_t axisVal = axis.getValue().getSExtValue();
 
   if (!inputShape.hasRank()) {
     inferredReturnShapes.push_back(ShapedTypeComponents());
     return success();
   }
 
   SmallVector<int64_t> outShape;

 
 LogicalResult tosa::ConcatOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes,
     OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   // Infer all dimension sizes by reducing based on inputs.
   int32_t axis =
-      attributes.get("axis").cast<IntegerAttr>().getValue().getSExtValue();
+      llvm::cast<IntegerAttr>(attributes.get("axis")).getValue().getSExtValue();
   llvm::SmallVector<int64_t> outputShape;
   bool hasRankedInput = false;
   for (auto operand : operands) {
     ShapeAdaptor operandShape = operands.getShape(operand);
     if (!operandShape.hasRank())
       continue;
 
     // Copy the Operand's rank.
for (int i = 0, s = operandShape.getRank(); i < s; i++) {
         return emitOptionalError(location,
                                  "Cannot concat tensors with different sizes"
                                  " on the non-axis dimension ",
                                  i);
     }
 
     hasRankedInput = true;
   }
-  Type inputType = operands.getType()[0].cast<TensorType>().getElementType();
+  Type inputType =
+      llvm::cast<TensorType>(operands.getType()[0]).getElementType();
   if (!hasRankedInput) {
     inferredReturnShapes.push_back(ShapedTypeComponents(inputType));
     return success();
   }
 
   // Determine the dimension size along the concatenation axis.
   int64_t concatDimSize = 0;
   for (auto operand : operands) {
LogicalResult tosa::ReshapeOp::inferReturnTypeComponents(
   }
 
   inferredReturnShapes.push_back(
       ShapedTypeComponents(newShapeValue, inputType));
   return success();
 }
 
 mlir::LogicalResult tosa::ReshapeOp::verify() {
-  ShapedType inputType = getInput1().getType().cast<ShapedType>();
-  ShapedType outputType = getType().cast<ShapedType>();
+  ShapedType inputType = llvm::cast<ShapedType>(getInput1().getType());
+  ShapedType outputType = llvm::cast<ShapedType>(getType());
 
   if (inputType.hasStaticShape() && outputType.hasStaticShape()) {
     int64_t inputElementsNum = inputType.getNumElements();
     int64_t outputElementsNum = outputType.getNumElements();
     if (inputElementsNum != outputElementsNum) {
       return emitOpError() << "Cannot reshape " << inputElementsNum
                            << " elements into " << outputElementsNum;
     }
static LogicalResult poolingInferReturnTypes(
 
   // Batch and number of channels are identical for pooling layer.
   outputShape[0] = inputShape.getDimSize(0);
   outputShape[3] = inputShape.getDimSize(3);
 
   int64_t height = inputShape.getDimSize(1);
   int64_t width = inputShape.getDimSize(2);
 
-  ArrayRef<int64_t> kernel = attributes.get("kernel").cast<DenseI64ArrayAttr>();
-  ArrayRef<int64_t> stride = attributes.get("stride").cast<DenseI64ArrayAttr>();
-  ArrayRef<int64_t> pad = attributes.get("pad").cast<DenseI64ArrayAttr>();
+  ArrayRef<int64_t> kernel =
+      llvm::cast<DenseI64ArrayAttr>(attributes.get("kernel"));
+  ArrayRef<int64_t> stride =
+      llvm::cast<DenseI64ArrayAttr>(attributes.get("stride"));
+  ArrayRef<int64_t> pad = llvm::cast<DenseI64ArrayAttr>(attributes.get("pad"));
 
   if (!ShapedType::isDynamic(height)) {
     int64_t padded = height + pad[0] + pad[1] - kernel[0];
     outputShape[1] = padded / stride[0] + 1;
   }
 
   if (!ShapedType::isDynamic(width)) {
     int64_t padded = width + pad[2] + pad[3] - kernel[1];
LogicalResult WhileOp::inferReturnTypeComponents(
   for (const ValueKnowledge &result : resultKnowledge) {
     inferredReturnShapes.push_back(result.getShapedTypeComponents());
   }
 
   return success();
 }
 
 std::optional<SmallVector<int64_t, 4>> ApplyScaleOp::getShapeForUnroll() {
-  if (auto vt = getType().dyn_cast<VectorType>())
+  if (auto vt = llvm::dyn_cast<VectorType>(getType()))
     return llvm::to_vector<4>(vt.getShape());
   return std::nullopt;
 }
 
 //===----------------------------------------------------------------------===//
 // TOSA Attribute Definitions.
 //===----------------------------------------------------------------------===//
 

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

for (auto scc = llvm::scc_begin(&callgraph); !scc.isAtEnd(); ++scc) {
         Operation *current = (*it)->getCallableRegion()->getParentOp();
         diag.attachNote(current->getLoc()) << "operation on recursion stack";
       }
       return diag;
     }
     return success();
   }
   if (attribute.getName().getValue() == kTargetTagAttrName) {
-    if (!attribute.getValue().isa<StringAttr>()) {
+    if (!llvm::isa<StringAttr>(attribute.getValue())) {
       return op->emitError()
              << attribute.getName() << " attribute must be a string";
     }
     return success();
   }
   if (attribute.getName().getValue() == kArgConsumedAttrName ||
       attribute.getName().getValue() == kArgReadOnlyAttrName) {
-    if (!attribute.getValue().isa<UnitAttr>()) {
+    if (!llvm::isa<UnitAttr>(attribute.getValue())) {
       return op->emitError()
              << attribute.getName() << " must be a unit attribute";
     }
     return success();
   }
   return emitError(op->getLoc())
          << "unknown attribute: " << attribute.getName();
 }

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

 
 /// Given a list of MappedValues, cast them to the value kind implied by the
 /// interface of the handle type, and dispatch to one of the callbacks.
 static DiagnosedSilenceableFailure dispatchMappedValues(
     Value handle, ArrayRef<transform::MappedValue> values,
     function_ref<LogicalResult(ArrayRef<Operation *>)> operationsFn,
     function_ref<LogicalResult(ArrayRef<transform::Param>)> paramsFn,
     function_ref<LogicalResult(ValueRange)> valuesFn) {
-  if (handle.getType().isa<transform::TransformHandleTypeInterface>()) {
+  if (llvm::isa<transform::TransformHandleTypeInterface>(handle.getType())) {
     SmallVector<Operation *> operations;
     operations.reserve(values.size());
     for (transform::MappedValue value : values) {
       if (auto *op = value.dyn_cast<Operation *>()) {
         operations.push_back(op);
         continue;
       }
       return emitSilenceableFailure(handle.getLoc())
              << "wrong kind of value provided for top-level operation handle";
     }
     if (failed(operationsFn(operations)))
       return DiagnosedSilenceableFailure::definiteFailure();
     return DiagnosedSilenceableFailure::success();
   }
 
-  if (handle.getType().isa<transform::TransformValueHandleTypeInterface>()) {
+  if (llvm::isa<transform::TransformValueHandleTypeInterface>(
+          handle.getType())) {
     SmallVector<Value> payloadValues;
     payloadValues.reserve(values.size());
     for (transform::MappedValue value : values) {
       if (auto v = value.dyn_cast<Value>()) {
         payloadValues.push_back(v);
         continue;
       }
       return emitSilenceableFailure(handle.getLoc())
              << "wrong kind of value provided for the top-level value handle";
     }
     if (failed(valuesFn(payloadValues)))
       return DiagnosedSilenceableFailure::definiteFailure();
     return DiagnosedSilenceableFailure::success();
   }
 
-  assert(handle.getType().isa<transform::TransformParamTypeInterface>() &&
+  assert(llvm::isa<transform::TransformParamTypeInterface>(handle.getType()) &&
          "unsupported kind of block argument");
   SmallVector<transform::Param> parameters;
   parameters.reserve(values.size());
   for (transform::MappedValue value : values) {
     if (auto attr = value.dyn_cast<Attribute>()) {
       parameters.push_back(attr);
       continue;
     }
return dispatchMappedValues(
       .checkAndReport();
 }
 
 LogicalResult
 transform::TransformState::setPayloadOps(Value value,
                                          ArrayRef<Operation *> targets) {
   assert(value != kTopLevelValue &&
          "attempting to reset the transformation root");
-  assert(value.getType().isa<TransformHandleTypeInterface>() &&
+  assert(llvm::isa<TransformHandleTypeInterface>(value.getType()) &&
          "wrong handle type");
 
   for (Operation *target : targets) {
     if (target)
       continue;
     return emitError(value.getLoc())
            << "attempting to assign a null payload op to this transform value";
   }
 
-  auto iface = value.getType().cast<TransformHandleTypeInterface>();
+  auto iface = llvm::cast<TransformHandleTypeInterface>(value.getType());
   DiagnosedSilenceableFailure result =
       iface.checkPayload(value.getLoc(), targets);
   if (failed(result.checkAndReport()))
     return failure();
 
   // Setting new payload for the value without cleaning it first is a misuse of
   // the API, assert here.
   SmallVector<Operation *> storedTargets(targets.begin(), targets.end());
   Mappings &mappings = getMapping(value);
   bool inserted =
       mappings.direct.insert({value, std::move(storedTargets)}).second;
   assert(inserted && "value is already associated with another list");
   (void)inserted;
 
   for (Operation *op : targets)
     mappings.reverse[op].push_back(value);
 
   return success();
 }
 
 LogicalResult
 transform::TransformState::setPayloadValues(Value handle,
                                             ValueRange payloadValues) {
   assert(handle != nullptr && "attempting to set params for a null value");
-  assert(handle.getType().isa<TransformValueHandleTypeInterface>() &&
+  assert(llvm::isa<TransformValueHandleTypeInterface>(handle.getType()) &&
          "wrong handle type");
 
   for (Value payload : payloadValues) {
     if (payload)
       continue;
     return emitError(handle.getLoc()) << "attempting to assign a null payload "
                                          "value to this transform handle";
   }
 
-  auto iface = handle.getType().cast<TransformValueHandleTypeInterface>();
+  auto iface = llvm::cast<TransformValueHandleTypeInterface>(handle.getType());
   SmallVector<Value> payloadValueVector = llvm::to_vector(payloadValues);
   DiagnosedSilenceableFailure result =
       iface.checkPayload(handle.getLoc(), payloadValueVector);
   if (failed(result.checkAndReport()))
     return failure();
 
   Mappings &mappings = getMapping(handle);
   bool inserted =
LogicalResult transform::TransformState::setParams(Value value,
 
   for (Attribute attr : params) {
     if (attr)
       continue;
     return emitError(value.getLoc())
            << "attempting to assign a null parameter to this transform value";
   }
 
-  auto valueType = value.getType().dyn_cast<TransformParamTypeInterface>();
+  auto valueType = llvm::dyn_cast<TransformParamTypeInterface>(value.getType());
   assert(value &&
          "cannot associate parameter with a value of non-parameter type");
   DiagnosedSilenceableFailure result =
       valueType.checkPayload(value.getLoc(), params);
   if (failed(result.checkAndReport()))
     return failure();
 
   Mappings &mappings = getMapping(value);
void transform::TransformState::recordValueHandleInvalidationByOpHandleOne(
   // may be reading invalid IR.
   if (invalidatedHandles.count(valueHandle))
     return;
 
   for (Operation *ancestor : potentialAncestors) {
     Operation *definingOp;
     std::optional<unsigned> resultNo;
     unsigned argumentNo, blockNo, regionNo;
-    if (auto opResult = payloadValue.dyn_cast<OpResult>()) {
+    if (auto opResult = llvm::dyn_cast<OpResult>(payloadValue)) {
       definingOp = opResult.getOwner();
       resultNo = opResult.getResultNumber();
     } else {
-      auto arg = payloadValue.cast<BlockArgument>();
+      auto arg = llvm::cast<BlockArgument>(payloadValue);
       definingOp = arg.getParentBlock()->getParentOp();
       argumentNo = arg.getArgNumber();
       blockNo = std::distance(arg.getOwner()->getParent()->begin(),
                               arg.getOwner()->getIterator());
       regionNo = arg.getOwner()->getParent()->getRegionNumber();
     }
     assert(definingOp && "expected the value to be defined by an op as result "
                          "or block argument");
for (Value otherHandle : otherValueHandles) {
             << "invalidated by this transform op that consumes its operand #"
             << operandNo
             << " and invalidates handles to the same values as associated with "
                "it";
         diag.attachNote(valueLoc) << "payload value";
       };
     }
 
-    if (auto opResult = payloadValue.dyn_cast<OpResult>()) {
+    if (auto opResult = llvm::dyn_cast<OpResult>(payloadValue)) {
       Operation *payloadOp = opResult.getOwner();
       recordOpHandleInvalidation(valueHandle, payloadOp, payloadValue);
     } else {
-      auto arg = payloadValue.dyn_cast<BlockArgument>();
+      auto arg = llvm::dyn_cast<BlockArgument>(payloadValue);
       for (Operation &payloadOp : *arg.getOwner())
         recordOpHandleInvalidation(valueHandle, &payloadOp, payloadValue);
     }
   }
 }
 
 LogicalResult transform::TransformState::checkAndRecordHandleInvalidation(
     TransformOpInterface transform) {
for (OpOperand &target : transform->getOpOperands()) {
     // Invalidate handles pointing to the operations nested in the operation
     // associated with the handle consumed by this operation.
     auto consumesTarget = [&](const MemoryEffects::EffectInstance &effect) {
       return isa<MemoryEffects::Free>(effect.getEffect()) &&
              effect.getValue() == target.get();
     };
     if (llvm::any_of(effects, consumesTarget)) {
       FULL_LDBG("----found consume effect -> SKIP\n");
-      if (target.get().getType().isa<TransformHandleTypeInterface>()) {
+      if (llvm::isa<TransformHandleTypeInterface>(target.get().getType())) {
         FULL_LDBG("----recordOpHandleInvalidation\n");
         ArrayRef<Operation *> payloadOps = getPayloadOps(target.get());
         recordOpHandleInvalidation(target, payloadOps);
-      } else if (target.get()
-                     .getType()
-                     .isa<TransformValueHandleTypeInterface>()) {
+      } else if (llvm::isa<TransformValueHandleTypeInterface>(
+                     target.get().getType())) {
         FULL_LDBG("----recordValueHandleInvalidation\n");
         recordValueHandleInvalidation(target);
       } else {
         FULL_LDBG("----not a TransformHandle -> SKIP AND DROP ON THE FLOOR\n");
       }
     } else {
       FULL_LDBG("----no consume effect -> SKIP\n");
     }
for (OpOperand &operand : transform->getOpOperands()) {
       });
       if (!isHandleConsumed(operand.get(), transform)) {
         FULL_LDBG("--handle not consumed -> SKIP\n");
         continue;
       }
       FULL_LDBG("--handle is consumed\n");
 
       Type operandType = operand.get().getType();
-      if (operandType.isa<TransformHandleTypeInterface>()) {
+      if (llvm::isa<TransformHandleTypeInterface>(operandType)) {
         FULL_LDBG("--checkRepeatedConsumptionInOperand for Operation*\n");
         DiagnosedSilenceableFailure check =
             checkRepeatedConsumptionInOperand<Operation *>(
                 getPayloadOps(operand.get()), transform,
                 operand.getOperandNumber());
         if (!check.succeeded()) {
           FULL_LDBG("----FAILED\n");
           return check;
         }
-      } else if (operandType.isa<TransformValueHandleTypeInterface>()) {
+      } else if (llvm::isa<TransformValueHandleTypeInterface>(operandType)) {
         FULL_LDBG("--checkRepeatedConsumptionInOperand For Value\n");
         DiagnosedSilenceableFailure check =
             checkRepeatedConsumptionInOperand<Value>(
                 getPayloadValues(operand.get()), transform,
                 operand.getOperandNumber());
         if (!check.succeeded()) {
           FULL_LDBG("----FAILED\n");
           return check;
#endif // LLVM_ENABLE_ABI_BREAKING_CHECKS
   // IR after that.
   SmallVector<Value> origOpFlatResults;
   SmallVector<Operation *> origAssociatedOps;
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
   DenseSet<Operation *> consumedPayloadOps;
 #endif // LLVM_ENABLE_ABI_BREAKING_CHECKS
   for (unsigned index : consumedOperands) {
     Value operand = transform->getOperand(index);
-    if (operand.getType().isa<TransformHandleTypeInterface>()) {
+    if (llvm::isa<TransformHandleTypeInterface>(operand.getType())) {
       for (Operation *payloadOp : getPayloadOps(operand)) {
         llvm::append_range(origOpFlatResults, payloadOp->getResults());
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
         if (options.getExpensiveChecksEnabled()) {
           // Store all consumed payload ops (and their nested ops) in a set for
           // extra error checking.
           payloadOp->walk(
               [&](Operation *op) { consumedPayloadOps.insert(op); });
         }
 #endif // LLVM_ENABLE_ABI_BREAKING_CHECKS
       }
       continue;
     }
-    if (operand.getType().isa<TransformValueHandleTypeInterface>()) {
+    if (llvm::isa<TransformValueHandleTypeInterface>(operand.getType())) {
       for (Value payloadValue : getPayloadValues(operand)) {
-        if (payloadValue.isa<OpResult>()) {
+        if (llvm::isa<OpResult>(payloadValue)) {
           origAssociatedOps.push_back(payloadValue.getDefiningOp());
           continue;
         }
         llvm::append_range(
             origAssociatedOps,
-            llvm::map_range(*payloadValue.cast<BlockArgument>().getOwner(),
+            llvm::map_range(*llvm::cast<BlockArgument>(payloadValue).getOwner(),
                             [](Operation &op) { return &op; }));
       }
       continue;
     }
     DiagnosedDefiniteFailure diag =
         emitDefiniteFailure(transform->getLoc())
         << "unexpectedly consumed a value that is not a handle as operand #"
         << index;
#endif // LLVM_ENABLE_ABI_BREAKING_CHECKS
   // to empty lists.
   if (result.isSilenceableFailure())
     results.setRemainingToEmpty(transform);
 
   // Remove the mapping for the operand if it is consumed by the operation. This
   // allows us to catch use-after-free with assertions later on.
   for (unsigned index : consumedOperands) {
     Value operand = transform->getOperand(index);
-    if (operand.getType().isa<TransformHandleTypeInterface>()) {
+    if (llvm::isa<TransformHandleTypeInterface>(operand.getType())) {
       forgetMapping(operand, origOpFlatResults);
-    } else if (operand.getType().isa<TransformValueHandleTypeInterface>()) {
+    } else if (llvm::isa<TransformValueHandleTypeInterface>(
+                   operand.getType())) {
       forgetValueMapping(operand, origAssociatedOps);
     }
   }
 
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
   if (options.getExpensiveChecksEnabled()) {
     // Remove erased ops from the transform state.
     for (Operation *op : consumedPayloadOps) {
DEBUG_WITH_TYPE(DEBUG_PRINT_AFTER_ALL, {
     getTopLevel()->print(llvm::dbgs());
   });
   return result;
 }
 
 LogicalResult transform::TransformState::updateStateFromResults(
     const TransformResults &results, ResultRange opResults) {
   for (OpResult result : opResults) {
-    if (result.getType().isa<TransformParamTypeInterface>()) {
+    if (llvm::isa<TransformParamTypeInterface>(result.getType())) {
       assert(results.isParam(result.getResultNumber()) &&
              "expected parameters for the parameter-typed result");
       if (failed(
               setParams(result, results.getParams(result.getResultNumber())))) {
         return failure();
       }
-    } else if (result.getType().isa<TransformValueHandleTypeInterface>()) {
+    } else if (llvm::isa<TransformValueHandleTypeInterface>(result.getType())) {
       assert(results.isValue(result.getResultNumber()) &&
              "expected values for value-type-result");
       if (failed(setPayloadValues(
               result, results.getValues(result.getResultNumber())))) {
         return failure();
       }
     } else {
       assert(!results.isParam(result.getResultNumber()) &&
if (partialResult.size() != expectedNumResults) {
     return failure();
   }
 
   // Check that the right kind of value was produced.
   for (const auto &[ptr, res] :
        llvm::zip(partialResult, transformOp->getResults())) {
     if (ptr.isNull())
       continue;
-    if (res.getType().template isa<TransformHandleTypeInterface>() &&
+    if (llvm::isa<TransformHandleTypeInterface>(res.getType()) &&
         !ptr.is<Operation *>()) {
       return emitDiag() << "application of " << transformOpName
                         << " expected to produce an Operation * for result #"
                         << res.getResultNumber();
     }
-    if (res.getType().template isa<TransformParamTypeInterface>() &&
+    if (llvm::isa<TransformParamTypeInterface>(res.getType()) &&
         !ptr.is<Attribute>()) {
       return emitDiag() << "application of " << transformOpName
                         << " expected to produce an Attribute for result #"
                         << res.getResultNumber();
     }
-    if (res.getType().template isa<TransformValueHandleTypeInterface>() &&
+    if (llvm::isa<TransformValueHandleTypeInterface>(res.getType()) &&
         !ptr.is<Value>()) {
       return emitDiag() << "application of " << transformOpName
                         << " expected to produce a Value for result #"
                         << res.getResultNumber();
     }
   }
   return success();
 }
for (const ApplyToEachResultList &partialResults : results) {
     assert(transformOp->getNumResults() == partialResults.size() &&
            "expected as many partial results as op as results");
     for (auto [i, value] : llvm::enumerate(partialResults))
       transposed[i].push_back(value);
   }
 
   for (OpResult r : transformOp->getResults()) {
     unsigned position = r.getResultNumber();
-    if (r.getType().isa<TransformParamTypeInterface>()) {
+    if (llvm::isa<TransformParamTypeInterface>(r.getType())) {
       transformResults.setParams(r,
                                  castVector<Attribute>(transposed[position]));
-    } else if (r.getType().isa<TransformValueHandleTypeInterface>()) {
+    } else if (llvm::isa<TransformValueHandleTypeInterface>(r.getType())) {
       transformResults.setValues(r, castVector<Value>(transposed[position]));
     } else {
       transformResults.set(r, castVector<Operation *>(transposed[position]));
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // Utilities for implementing transform ops with regions.
 //===----------------------------------------------------------------------===//
 
 void transform::detail::prepareValueMappings(
     SmallVectorImpl<SmallVector<transform::MappedValue>> &mappings,
     ValueRange values, const transform::TransformState &state) {
   for (Value operand : values) {
     SmallVector<MappedValue> &mapped = mappings.emplace_back();
-    if (operand.getType().isa<TransformHandleTypeInterface>()) {
+    if (llvm::isa<TransformHandleTypeInterface>(operand.getType())) {
       llvm::append_range(mapped, state.getPayloadOps(operand));
-    } else if (operand.getType().isa<TransformValueHandleTypeInterface>()) {
+    } else if (llvm::isa<TransformValueHandleTypeInterface>(
+                   operand.getType())) {
       llvm::append_range(mapped, state.getPayloadValues(operand));
     } else {
-      assert(operand.getType().isa<TransformParamTypeInterface>() &&
+      assert(llvm::isa<TransformParamTypeInterface>(operand.getType()) &&
              "unsupported kind of transform dialect value");
       llvm::append_range(mapped, state.getParams(operand));
     }
   }
 }
 
 void transform::detail::forwardTerminatorOperands(
     Block *block, transform::TransformState &state,
     transform::TransformResults &results) {
   for (auto &&[terminatorOperand, result] :
        llvm::zip(block->getTerminator()->getOperands(),
                  block->getParentOp()->getOpResults())) {
-    if (result.getType().isa<transform::TransformHandleTypeInterface>()) {
+    if (llvm::isa<transform::TransformHandleTypeInterface>(result.getType())) {
       results.set(result, state.getPayloadOps(terminatorOperand));
-    } else if (result.getType()
-                   .isa<transform::TransformValueHandleTypeInterface>()) {
+    } else if (llvm::isa<transform::TransformValueHandleTypeInterface>(
+                   result.getType())) {
       results.setValues(result, state.getPayloadValues(terminatorOperand));
     } else {
-      assert(result.getType().isa<transform::TransformParamTypeInterface>() &&
-             "unhandled transform type interface");
+      assert(
+          llvm::isa<transform::TransformParamTypeInterface>(result.getType()) &&
       results.setParams(result, state.getParams(terminatorOperand));
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // Utilities for PossibleTopLevelTransformOpTrait.
 //===----------------------------------------------------------------------===//
transform::detail::verifyPossibleTopLevelTransformOpTrait(Operation *op) {
   if (!llvm::hasNItems(*bodyRegion, 1))
     return op->emitOpError() << "expects a single-block region";
 
   Block *body = &bodyRegion->front();
   if (body->getNumArguments() == 0) {
     return op->emitOpError()
            << "expects the entry block to have at least one argument";
   }
-  if (!body->getArgument(0).getType().isa<TransformHandleTypeInterface>()) {
+  if (!llvm::isa<TransformHandleTypeInterface>(
+          body->getArgument(0).getType())) {
     return op->emitOpError()
            << "expects the first entry block argument to be of type "
               "implementing TransformHandleTypeInterface";
   }
   BlockArgument arg = body->getArgument(0);
   if (op->getNumOperands() != 0) {
     if (arg.getType() != op->getOperand(0).getType()) {
       return op->emitOpError()
              << "expects the type of the block argument to match "
                 "the type of the operand";
     }
   }
   for (BlockArgument arg : body->getArguments().drop_front()) {
-    if (arg.getType()
-            .isa<TransformHandleTypeInterface, TransformParamTypeInterface,
-                 TransformValueHandleTypeInterface>())
+    if (llvm::isa<TransformHandleTypeInterface, TransformParamTypeInterface,
+                  TransformValueHandleTypeInterface>(arg.getType()))
       continue;
 
     InFlightDiagnostic diag =
         op->emitOpError()
         << "expects trailing entry block arguments to be of type implementing "
            "TransformHandleTypeInterface, TransformValueHandleTypeInterface or "
            "TransformParamTypeInterface";
     diag.attachNote() << "argument #" << arg.getArgNumber() << " does not";

 //===----------------------------------------------------------------------===//
 
 void transform::detail::getParamProducerTransformOpTraitEffects(
     Operation *op, SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   producesHandle(op->getResults(), effects);
   bool hasPayloadOperands = false;
   for (Value operand : op->getOperands()) {
     onlyReadsHandle(operand, effects);
-    if (operand.getType()
-            .isa<TransformHandleTypeInterface,
-                 TransformValueHandleTypeInterface>())
+    if (llvm::isa<TransformHandleTypeInterface,
+                  TransformValueHandleTypeInterface>(operand.getType()))
       hasPayloadOperands = true;
   }
   if (hasPayloadOperands)
     onlyReadsPayload(effects);
 }
 
 LogicalResult
 transform::detail::verifyParamProducerTransformOpTrait(Operation *op) {
   // Interfaces can be attached dynamically, so this cannot be a static
   // assert.
   if (!op->getName().getInterface<MemoryEffectOpInterface>()) {
     llvm::report_fatal_error(
         Twine("ParamProducerTransformOpTrait must be attached to an op that "
               "implements MemoryEffectsOpInterface, found on ") +
         op->getName().getStringRef());
   }
   for (Value result : op->getResults()) {
-    if (result.getType().isa<TransformParamTypeInterface>())
+    if (llvm::isa<TransformParamTypeInterface>(result.getType()))
       continue;
     return op->emitOpError()
            << "ParamProducerTransformOpTrait attached to this op expects "
               "result types to implement TransformParamTypeInterface";
   }
   return success();
 }
 

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

 }
 
 bool transform::CastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   assert(inputs.size() == 1 && "expected one input");
   assert(outputs.size() == 1 && "expected one output");
   return llvm::all_of(
       std::initializer_list<Type>{inputs.front(), outputs.front()},
       [](Type ty) {
-        return ty
-            .isa<pdl::OperationType, transform::TransformHandleTypeInterface>();
+        return llvm::isa<pdl::OperationType,
+                         transform::TransformHandleTypeInterface>(ty);
       });
 }
 
 //===----------------------------------------------------------------------===//
 // ForeachMatchOp
 //===----------------------------------------------------------------------===//
 
 /// Applies matcher operations from the given `block` assigning `op` as the
for (Operation *root : state.getPayloadOps(getRoot())) {
     if (walkResult.wasInterrupted())
       return DiagnosedSilenceableFailure::definiteFailure();
   }
 
   // The root operation should not have been affected, so we can just reassign
   // the payload to the result. Note that we need to consume the root handle to
   // make sure any handles to operations inside, that could have been affected
   // by actions, are invalidated.
-  results.set(getUpdated().cast<OpResult>(), state.getPayloadOps(getRoot()));
+  results.set(llvm::cast<OpResult>(getUpdated()),
+              state.getPayloadOps(getRoot()));
   return DiagnosedSilenceableFailure::success();
 }
 
 void transform::ForeachMatchOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   // Bail if invalid.
   if (getOperation()->getNumOperands() < 1 ||
       getOperation()->getNumResults() < 1) {
for (Operation *op : payloadOps) {
     for (unsigned i = 0; i < getNumResults(); ++i) {
       ArrayRef<Operation *> yieldedOps =
           state.getPayloadOps(getYieldOp().getOperand(i));
       resultOps[i].append(yieldedOps.begin(), yieldedOps.end());
     }
   }
 
   for (unsigned i = 0; i < getNumResults(); ++i)
-    results.set(getResult(i).cast<OpResult>(), resultOps[i]);
+    results.set(llvm::cast<OpResult>(getResult(i)), resultOps[i]);
 
   return DiagnosedSilenceableFailure::success();
 }
 
 void transform::ForeachOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   BlockArgument iterVar = getIterationVariable();
   if (any_of(getBody().front().without_terminator(), [&](Operation &op) {

 }
 
 LogicalResult transform::ForeachOp::verify() {
   auto yieldOp = getYieldOp();
   if (getNumResults() != yieldOp.getNumOperands())
     return emitOpError() << "expects the same number of results as the "
                             "terminator has operands";
   for (Value v : yieldOp.getOperands())
-    if (!v.getType().isa<TransformHandleTypeInterface>())
+    if (!llvm::isa<TransformHandleTypeInterface>(v.getType()))
       return yieldOp->emitOpError("expects operands to have types implementing "
                                   "TransformHandleTypeInterface");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // GetClosestIsolatedParentOp
 //===----------------------------------------------------------------------===//
 
 DiagnosedSilenceableFailure transform::GetClosestIsolatedParentOp::apply(
     transform::TransformResults &results, transform::TransformState &state) {
   SetVector<Operation *> parents;
   for (Operation *target : state.getPayloadOps(getTarget())) {
     Operation *parent =
         target->getParentWithTrait<OpTrait::IsIsolatedFromAbove>();
     if (!parent) {
       DiagnosedSilenceableFailure diag =
           emitSilenceableError()
           << "could not find an isolated-from-above parent op";
       diag.attachNote(target->getLoc()) << "target op";
       return diag;
     }
     parents.insert(parent);
   }
-  results.set(getResult().cast<OpResult>(), parents.getArrayRef());
+  results.set(llvm::cast<OpResult>(getResult()), parents.getArrayRef());
   return DiagnosedSilenceableFailure::success();
 }
 
 //===----------------------------------------------------------------------===//
 // GetConsumersOfResult
 //===----------------------------------------------------------------------===//
 
 DiagnosedSilenceableFailure
 transform::GetConsumersOfResult::apply(transform::TransformResults &results,
                                        transform::TransformState &state) {
   int64_t resultNumber = getResultNumber();
   ArrayRef<Operation *> payloadOps = state.getPayloadOps(getTarget());
   if (payloadOps.empty()) {
-    results.set(getResult().cast<OpResult>(), {});
+    results.set(llvm::cast<OpResult>(getResult()), {});
     return DiagnosedSilenceableFailure::success();
   }
   if (payloadOps.size() != 1)
     return emitDefiniteFailure()
            << "handle must be mapped to exactly one payload op";
 
   Operation *target = payloadOps.front();
   if (target->getNumResults() <= resultNumber)
     return emitDefiniteFailure() << "result number overflow";
-  results.set(getResult().cast<OpResult>(),
+  results.set(llvm::cast<OpResult>(getResult()),
               llvm::to_vector(target->getResult(resultNumber).getUsers()));
   return DiagnosedSilenceableFailure::success();
 }
 
 //===----------------------------------------------------------------------===//
 // GetDefiningOp
 //===----------------------------------------------------------------------===//
 
 DiagnosedSilenceableFailure
 transform::GetDefiningOp::apply(transform::TransformResults &results,
                                 transform::TransformState &state) {
   SmallVector<Operation *> definingOps;
   for (Value v : state.getPayloadValues(getTarget())) {
-    if (v.isa<BlockArgument>()) {
+    if (llvm::isa<BlockArgument>(v)) {
       DiagnosedSilenceableFailure diag =
           emitSilenceableError() << "cannot get defining op of block argument";
       diag.attachNote(v.getLoc()) << "target value";
       return diag;
     }
     definingOps.push_back(v.getDefiningOp());
   }
-  results.set(getResult().cast<OpResult>(), definingOps);
+  results.set(llvm::cast<OpResult>(getResult()), definingOps);
   return DiagnosedSilenceableFailure::success();
 }
 
 //===----------------------------------------------------------------------===//
 // GetProducerOfOperand
 //===----------------------------------------------------------------------===//
 
 DiagnosedSilenceableFailure
if (!producer) {
           emitSilenceableError()
           << "could not find a producer for operand number: " << operandNumber
           << " of " << *target;
       diag.attachNote(target->getLoc()) << "target op";
       return diag;
     }
     producers.push_back(producer);
   }
-  results.set(getResult().cast<OpResult>(), producers);
+  results.set(llvm::cast<OpResult>(getResult()), producers);
   return DiagnosedSilenceableFailure::success();
 }
 
 //===----------------------------------------------------------------------===//
 // GetResultOp
 //===----------------------------------------------------------------------===//
 
 DiagnosedSilenceableFailure
 transform::GetResultOp::apply(transform::TransformResults &results,
                               transform::TransformState &state) {
   int64_t resultNumber = getResultNumber();
   SmallVector<Value> opResults;
   for (Operation *target : state.getPayloadOps(getTarget())) {
     if (resultNumber >= target->getNumResults()) {
       DiagnosedSilenceableFailure diag =
           emitSilenceableError() << "targeted op does not have enough results";
       diag.attachNote(target->getLoc()) << "target op";
       return diag;
     }
     opResults.push_back(target->getOpResult(resultNumber));
   }
-  results.setValues(getResult().cast<OpResult>(), opResults);
+  results.setValues(llvm::cast<OpResult>(getResult()), opResults);
   return DiagnosedSilenceableFailure::success();
 }
 
 //===----------------------------------------------------------------------===//
 // IncludeOp
 //===----------------------------------------------------------------------===//
 
 /// Applies the transform ops contained in `block`. Maps `results` to the same
transform::MatchParamCmpIOp::apply(transform::TransformResults &results,
 
   if (params.size() != references.size()) {
     return emitSilenceableError()
            << "parameters have different payload lengths (" << params.size()
            << " vs " << references.size() << ")";
   }
 
   for (auto &&[i, param, reference] : llvm::enumerate(params, references)) {
-    auto intAttr = param.dyn_cast<IntegerAttr>();
-    auto refAttr = reference.dyn_cast<IntegerAttr>();
+    auto intAttr = llvm::dyn_cast<IntegerAttr>(param);
+    auto refAttr = llvm::dyn_cast<IntegerAttr>(reference);
     if (!intAttr || !refAttr) {
       return emitDefiniteFailure()
              << "non-integer parameter value not expected";
     }
     if (intAttr.getType() != refAttr.getType()) {
       return emitDefiniteFailure()
              << "mismatching integer attribute types in parameter #" << i;
     }

 
 DiagnosedSilenceableFailure
 transform::MergeHandlesOp::apply(transform::TransformResults &results,
                                  transform::TransformState &state) {
   SmallVector<Operation *> operations;
   for (Value operand : getHandles())
     llvm::append_range(operations, state.getPayloadOps(operand));
   if (!getDeduplicate()) {
-    results.set(getResult().cast<OpResult>(), operations);
+    results.set(llvm::cast<OpResult>(getResult()), operations);
     return DiagnosedSilenceableFailure::success();
   }
 
   SetVector<Operation *> uniqued(operations.begin(), operations.end());
-  results.set(getResult().cast<OpResult>(), uniqued.getArrayRef());
+  results.set(llvm::cast<OpResult>(getResult()), uniqued.getArrayRef());
   return DiagnosedSilenceableFailure::success();
 }
 
 bool transform::MergeHandlesOp::allowsRepeatedHandleOperands() {
   // Handles may be the same if deduplicating is enabled.
   return getDeduplicate();
 }
 
for (auto &&en : llvm::enumerate(state.getPayloadOps(getHandle()))) {
     int64_t resultNum = en.index();
     if (resultNum >= getNumResults())
       resultNum = *getOverflowResult();
     resultHandles[resultNum].push_back(en.value());
   }
 
   // Set transform op results.
   for (auto &&it : llvm::enumerate(resultHandles))
-    results.set(getResult(it.index()).cast<OpResult>(), it.value());
+    results.set(llvm::cast<OpResult>(getResult(it.index())), it.value());
 
   return DiagnosedSilenceableFailure::success();
 }
 
 void transform::SplitHandleOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   onlyReadsHandle(getHandle(), effects);
   producesHandle(getResults(), effects);
transform::PDLMatchOp::apply(transform::TransformResults &results,
   SmallVector<Operation *> targets;
   for (Operation *root : state.getPayloadOps(getRoot())) {
     if (failed(extension->findAllMatches(
             getPatternName().getLeafReference().getValue(), root, targets))) {
       emitDefiniteFailure()
           << "could not find pattern '" << getPatternName() << "'";
     }
   }
-  results.set(getResult().cast<OpResult>(), targets);
+  results.set(llvm::cast<OpResult>(getResult()), targets);
   return DiagnosedSilenceableFailure::success();
 }
 
 void transform::PDLMatchOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   onlyReadsHandle(getRoot(), effects);
   producesHandle(getMatched(), effects);
   onlyReadsPayload(effects);
 }
 
 //===----------------------------------------------------------------------===//
 // ReplicateOp
 //===----------------------------------------------------------------------===//
 
 DiagnosedSilenceableFailure
 transform::ReplicateOp::apply(transform::TransformResults &results,
                               transform::TransformState &state) {
   unsigned numRepetitions = state.getPayloadOps(getPattern()).size();
   for (const auto &en : llvm::enumerate(getHandles())) {
     Value handle = en.value();
-    if (handle.getType().isa<TransformHandleTypeInterface>()) {
+    if (llvm::isa<TransformHandleTypeInterface>(handle.getType())) {
       ArrayRef<Operation *> current = state.getPayloadOps(handle);
       SmallVector<Operation *> payload;
       payload.reserve(numRepetitions * current.size());
       for (unsigned i = 0; i < numRepetitions; ++i)
         llvm::append_range(payload, current);
-      results.set(getReplicated()[en.index()].cast<OpResult>(), payload);
+      results.set(llvm::cast<OpResult>(getReplicated()[en.index()]), payload);
     } else {
-      assert(handle.getType().isa<TransformParamTypeInterface>() &&
+      assert(llvm::isa<TransformParamTypeInterface>(handle.getType()) &&
              "expected param type");
       ArrayRef<Attribute> current = state.getParams(handle);
       SmallVector<Attribute> params;
       params.reserve(numRepetitions * current.size());
       for (unsigned i = 0; i < numRepetitions; ++i)
         llvm::append_range(params, current);
-      results.setParams(getReplicated()[en.index()].cast<OpResult>(), params);
+      results.setParams(llvm::cast<OpResult>(getReplicated()[en.index()]),
+                        params);
     }
   }
   return DiagnosedSilenceableFailure::success();
 }
 
 void transform::ReplicateOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   onlyReadsHandle(getPattern(), effects);

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

 
 //===----------------------------------------------------------------------===//
 // transform::ParamType
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 transform::ParamType::verify(function_ref<InFlightDiagnostic()> emitError,
                              Type type) {
-  IntegerType intType = type.dyn_cast<IntegerType>();
+  IntegerType intType = llvm::dyn_cast<IntegerType>(type);
   if (!intType || intType.getWidth() > 64)
     return emitError() << "only supports integer types with width <=64";
   return success();
 }
 
 DiagnosedSilenceableFailure
 transform::ParamType::checkPayload(Location loc,
                                    ArrayRef<Attribute> payload) const {
   for (Attribute attr : payload) {
-    auto integerAttr = attr.dyn_cast<IntegerAttr>();
+    auto integerAttr = llvm::dyn_cast<IntegerAttr>(attr);
     if (!integerAttr) {
       return emitSilenceableError(loc)
              << "expected parameter to be an integer attribute, got " << attr;
     }
     if (integerAttr.getType() != getType()) {
       return emitSilenceableError(loc)
              << "expected the type of the parameter attribute ("
              << integerAttr.getType() << ") to match the parameter type ("

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

 /// looks "under the hood" of a constant value with dense attributes
 /// and a constant mask operation (since the client may be called at
 /// various stages during progressive lowering).
 static MaskFormat getMaskFormat(Value mask) {
   if (auto c = mask.getDefiningOp<arith::ConstantOp>()) {
     // Inspect constant dense values. We count up for bits that
     // are set, count down for bits that are cleared, and bail
     // when a mix is detected.
-    if (auto denseElts = c.getValue().dyn_cast<DenseIntElementsAttr>()) {
+    if (auto denseElts = llvm::dyn_cast<DenseIntElementsAttr>(c.getValue())) {
       int64_t val = 0;
       for (bool b : denseElts.getValues<bool>())
         if (b && val >= 0)
           val++;
         else if (!b && val <= 0)
           val--;
         else
           return MaskFormat::Unknown;
       if (val > 0)
         return MaskFormat::AllTrue;
       if (val < 0)
         return MaskFormat::AllFalse;
     }
   } else if (auto m = mask.getDefiningOp<ConstantMaskOp>()) {
     // Inspect constant mask index. If the index exceeds the
     // dimension size, all bits are set. If the index is zero
     // or less, no bits are set.
     ArrayAttr masks = m.getMaskDimSizes();
     auto shape = m.getType().getShape();
     bool allTrue = true;
     bool allFalse = true;
     for (auto [maskIdx, dimSize] : llvm::zip_equal(masks, shape)) {
-      int64_t i = maskIdx.cast<IntegerAttr>().getInt();
+      int64_t i = llvm::cast<IntegerAttr>(maskIdx).getInt();
       if (i < dimSize)
         allTrue = false;
       if (i > 0)
         allFalse = false;
     }
     if (allTrue)
       return MaskFormat::AllTrue;
     if (allFalse)
static bool isSupportedCombiningKind(CombiningKind combiningKind,
   case CombiningKind::MAXUI:
   case CombiningKind::MAXSI:
   case CombiningKind::AND:
   case CombiningKind::OR:
   case CombiningKind::XOR:
     return elementType.isIntOrIndex();
   case CombiningKind::MINF:
   case CombiningKind::MAXF:
-    return elementType.isa<FloatType>();
+    return llvm::isa<FloatType>(elementType);
   }
   return false;
 }
 
 /// Return true if the last dimension of the MemRefType has unit stride. Also
 /// return true for memrefs with no strides.
 bool mlir::vector::isLastMemrefDimUnitStride(MemRefType type) {
   int64_t offset;
   SmallVector<int64_t> strides;
   auto successStrides = getStridesAndOffset(type, strides, offset);
   return succeeded(successStrides) && (strides.empty() || strides.back() == 1);
 }
 
 AffineMap mlir::vector::getTransferMinorIdentityMap(ShapedType shapedType,
                                                     VectorType vectorType) {
   int64_t elementVectorRank = 0;
   VectorType elementVectorType =
-      shapedType.getElementType().dyn_cast<VectorType>();
+      llvm::dyn_cast<VectorType>(shapedType.getElementType());
   if (elementVectorType)
     elementVectorRank += elementVectorType.getRank();
   // 0-d transfers are to/from tensor<t>/memref<t> and vector<1xt>.
   // TODO: replace once we have 0-d vectors.
   if (shapedType.getRank() == 0 &&
       vectorType.getShape() == ArrayRef<int64_t>{1})
     return AffineMap::get(
         /*numDims=*/0, /*numSymbols=*/0,
for (unsigned i = 0, e = transferA.indices().size(); i < e; i++) {
     auto indexB = transferB.indices()[i].getDefiningOp<arith::ConstantOp>();
     // If any of the indices are dynamic we cannot prove anything.
     if (!indexA || !indexB)
       continue;
 
     if (i < rankOffset) {
       // For leading dimensions, if we can prove that index are different we
       // know we are accessing disjoint slices.
-      if (indexA.getValue().cast<IntegerAttr>().getInt() !=
-          indexB.getValue().cast<IntegerAttr>().getInt())
+      if (llvm::cast<IntegerAttr>(indexA.getValue()).getInt() !=
+          llvm::cast<IntegerAttr>(indexB.getValue()).getInt())
         return true;
     } else {
       // For this dimension, we slice a part of the memref we need to make sure
       // the intervals accessed don't overlap.
       int64_t distance =
-          std::abs(indexA.getValue().cast<IntegerAttr>().getInt() -
-                   indexB.getValue().cast<IntegerAttr>().getInt());
+          std::abs(llvm::cast<IntegerAttr>(indexA.getValue()).getInt() -
+                   llvm::cast<IntegerAttr>(indexB.getValue()).getInt());
       if (distance >= transferA.getVectorType().getDimSize(i - rankOffset))
         return true;
     }
   }
   return false;
 }
 
 bool mlir::vector::isDisjointTransferSet(VectorTransferOpInterface transferA,
MultiDimReductionOp::getShapeForUnroll() {
   return llvm::to_vector<4>(getSourceVectorType().getShape());
 }
 
 LogicalResult MultiDimReductionOp::verify() {
   SmallVector<int64_t> targetShape;
   Type inferredReturnType;
   for (auto it : llvm::enumerate(getSourceVectorType().getShape()))
     if (!llvm::any_of(getReductionDims().getValue(), [&](Attribute attr) {
-          return attr.cast<IntegerAttr>().getValue() == it.index();
+          return llvm::cast<IntegerAttr>(attr).getValue() == it.index();
         }))
       targetShape.push_back(it.value());
   // TODO: update to also allow 0-d vectors when available.
   if (targetShape.empty())
     inferredReturnType = getSourceVectorType().getElementType();
   else
     inferredReturnType =
         VectorType::get(targetShape, getSourceVectorType().getElementType());

 
 void vector::ReductionOp::build(OpBuilder &builder, OperationState &result,
                                 CombiningKind kind, Value vector) {
   build(builder, result, kind, vector, /*acc=*/Value());
 }
 
 void vector::ReductionOp::build(OpBuilder &builder, OperationState &result,
                                 CombiningKind kind, Value vector, Value acc) {
-  build(builder, result, vector.getType().cast<VectorType>().getElementType(),
-        kind, vector, acc);
+  build(builder, result,
+        llvm::cast<VectorType>(vector.getType()).getElementType(), kind, vector,
+        acc);
 }
 
 LogicalResult ReductionOp::verify() {
   // Verify for 0-D and 1-D vector.
   int64_t rank = getSourceVectorType().getRank();
   if (rank > 1)
     return emitOpError("unsupported reduction rank: ") << rank;
 
if (parser.parseAttribute(dictAttr) || parser.parseOperand(lhsInfo) ||
     return failure();
   result.attributes.append(dictAttr.getValue().begin(),
                            dictAttr.getValue().end());
 
   // Convert array of string into an array of IteratyType enums. This is needed,
   // because tests still use the old format when 'iterator_types' attribute is
   // represented as an array of strings.
   // TODO: Remove this conversion once tests are fixed.
-  ArrayAttr iteratorTypes =
-      result.attributes.get(getIteratorTypesAttrName(result.name))
-          .cast<ArrayAttr>();
+  ArrayAttr iteratorTypes = llvm::cast<ArrayAttr>(
+      result.attributes.get(getIteratorTypesAttrName(result.name)));
 
   SmallVector<Attribute> iteratorTypeAttrs;
 
   for (StringRef s : iteratorTypes.getAsValueRange<StringAttr>()) {
     auto maybeIteratorType = symbolizeIteratorType(s);
     if (!maybeIteratorType.has_value())
       return parser.emitError(loc) << "unexpected iterator_type (" << s << ")";
 
result.addAttribute(
         CombiningKindAttr::get(result.getContext(),
                                ContractionOp::getDefaultKind()));
   }
   if (masksInfo.empty())
     return success();
   if (masksInfo.size() != 2)
     return parser.emitError(parser.getNameLoc(),
                             "expected zero or exactly 2 vector mask operands");
-  auto lhsType = types[0].cast<VectorType>();
-  auto rhsType = types[1].cast<VectorType>();
+  auto lhsType = llvm::cast<VectorType>(types[0]);
+  auto rhsType = llvm::cast<VectorType>(types[1]);
   auto maskElementType = parser.getBuilder().getI1Type();
   std::array<Type, 2> maskTypes = {
       VectorType::Builder(lhsType).setElementType(maskElementType),
       VectorType::Builder(rhsType).setElementType(maskElementType)};
   if (parser.resolveOperands(masksInfo, maskTypes, loc, result.operands))
     return failure();
   return success();
 }
 
 void ContractionOp::print(OpAsmPrinter &p) {
   // TODO: Unify printing code with linalg ops.
   auto attrNames = getTraitAttrNames();
   llvm::StringSet<> traitAttrsSet;
   traitAttrsSet.insert(attrNames.begin(), attrNames.end());
   SmallVector<NamedAttribute, 8> attrs;
   for (auto attr : (*this)->getAttrs()) {
     if (attr.getName() == getIteratorTypesAttrName()) {
       auto iteratorTypes =
-          attr.getValue()
-              .cast<ArrayAttr>()
+          llvm::cast<ArrayAttr>(attr.getValue())
               .getAsValueRange<IteratorTypeAttr, IteratorType>();
       // Convert IteratorType enums into the string representation. This is
       // needed, because tests still use the old format when 'iterator_types'
       // attribute is represented as an array of strings.
       // TODO: Remove this conversion once tests are fixed.
       SmallVector<Attribute> iteratorTypeNames = llvm::to_vector(
           llvm::map_range(iteratorTypes, [&](IteratorType t) -> Attribute {
             return StringAttr::get(getContext(), stringifyIteratorType(t));
for (int64_t i = 0, e = rhsType.getRank(); i < e; ++i) {
     if (rhsContractingDimSet.count(i) > 0 || rhsBatchDimSet.count(i) > 0)
       continue;
     expectedResultDims.push_back(rhsType.getDimSize(i));
   }
 
   // Verify 'expectedResultDims'.
   if (expectedResultDims.empty()) {
     // No batch or free dimension implies a scalar result.
-    if (resType.isa<VectorType>() || accType.isa<VectorType>())
+    if (llvm::isa<VectorType>(resType) || llvm::isa<VectorType>(accType))
       return op.emitOpError("invalid accumulator/result vector shape");
   } else {
     // At least one batch or free dimension implies a vector result.
-    auto resVectorType = resType.dyn_cast<VectorType>();
-    auto accVectorType = accType.dyn_cast<VectorType>();
+    auto resVectorType = llvm::dyn_cast<VectorType>(resType);
+    auto accVectorType = llvm::dyn_cast<VectorType>(accType);
     if (!resVectorType || !accVectorType)
       return op.emitOpError("invalid accumulator/result vector shape");
 
     // Infer expected result vector type. Lhs + rhs map and lhs + rhs vector
     // types fully define the result vector type. This assumes the affine maps
     // are well-formed, which must have been verified already.
     MLIRContext *ctx = op.getContext();
     AffineMap lhsMap = op.getIndexingMapsArray()[0];

 }
 
 LogicalResult ContractionOp::verify() {
   VectorType lhsType = getLhsType();
   VectorType rhsType = getRhsType();
   Type accType = getAccType();
   Type resType = getResultType();
 
-  if (lhsType.getElementType().isa<IntegerType>()) {
+  if (llvm::isa<IntegerType>(lhsType.getElementType())) {
     if (!lhsType.getElementType().isSignlessInteger())
       return emitOpError("only supports signless integer types");
   }
 
   // Verify that an indexing map was specified for each vector operand.
   if (getIndexingMapsArray().size() != 3)
     return emitOpError("expected an indexing map for each vector operand");
 
   // Verify that each index map has 'numIterators' inputs, no symbols, and
   // that the number of map outputs equals the rank of its associated
   // vector operand.
   unsigned numIterators = getIteratorTypes().getValue().size();
   for (const auto &it : llvm::enumerate(getIndexingMapsArray())) {
     auto index = it.index();
     auto map = it.value();
     if (map.getNumSymbols() != 0)
       return emitOpError("expected indexing map ")
              << index << " to have no symbols";
-    auto vectorType = getOperand(index).getType().dyn_cast<VectorType>();
+    auto vectorType = llvm::dyn_cast<VectorType>(getOperand(index).getType());
     unsigned rank = vectorType ? vectorType.getShape().size() : 0;
     // Verify that the map has the right number of inputs, outputs, and indices.
     // This also correctly accounts for (..) -> () for rank-0 results.
     if (map.getNumDims() != numIterators)
       return emitOpError("expected indexing map ")
              << index << " to have " << numIterators << " number of inputs";
     if (map.getNumResults() != rank)
       return emitOpError("expected indexing map ")
if (!verifyDimMap(lhsType, rhsType, batchDimMap))
     return emitOpError("invalid batch dimension map");
 
   // Verify 'accType' and 'resType' shape.
   if (failed(verifyOutputShape(*this, lhsType, rhsType, accType, resType,
                                contractingDimMap, batchDimMap)))
     return failure();
 
   // Verify supported combining kind.
-  auto vectorType = resType.dyn_cast<VectorType>();
+  auto vectorType = llvm::dyn_cast<VectorType>(resType);
   auto elementType = vectorType ? vectorType.getElementType() : resType;
   if (!isSupportedCombiningKind(getKind(), elementType))
     return emitOpError("unsupported contraction type");
 
   return success();
 }
 
 // MaskableOpInterface methods.
static int64_t getResultIndex(AffineMap map, AffineExpr targetExpr) {
   return -1;
 }
 
 static std::vector<std::pair<int64_t, int64_t>>
 getDimMap(ArrayRef<AffineMap> indexingMaps, ArrayAttr iteratorTypes,
           IteratorType targetIteratorType, MLIRContext *context) {
   std::vector<std::pair<int64_t, int64_t>> dimMap;
   for (const auto &it : llvm::enumerate(iteratorTypes)) {
-    auto iteratorType = it.value().cast<IteratorTypeAttr>().getValue();
+    auto iteratorType = llvm::cast<IteratorTypeAttr>(it.value()).getValue();
     if (iteratorType != targetIteratorType)
       continue;
     // Search lhs/rhs map results for 'targetExpr'.
     auto targetExpr = getAffineDimExpr(it.index(), context);
     int64_t lhsDim = getResultIndex(indexingMaps[0], targetExpr);
     int64_t rhsDim = getResultIndex(indexingMaps[1], targetExpr);
     if (lhsDim >= 0 && rhsDim >= 0)
       dimMap.emplace_back(lhsDim, rhsDim);
   }
   return dimMap;
 }
 
 void ContractionOp::getIterationBounds(
     SmallVectorImpl<int64_t> &iterationBounds) {
   auto lhsShape = getLhsType().getShape();
-  auto resVectorType = getResultType().dyn_cast<VectorType>();
+  auto resVectorType = llvm::dyn_cast<VectorType>(getResultType());
   SmallVector<AffineMap, 4> indexingMaps(getIndexingMapsArray());
   SmallVector<int64_t, 2> iterationShape;
   for (const auto &it : llvm::enumerate(getIteratorTypes())) {
     // Search lhs/rhs map results for 'targetExpr'.
     auto targetExpr = getAffineDimExpr(it.index(), getContext());
-    auto iteratorType = it.value().cast<IteratorTypeAttr>().getValue();
+    auto iteratorType = llvm::cast<IteratorTypeAttr>(it.value()).getValue();
     if (iteratorType == IteratorType::reduction) {
       // Get reduction dim size from lhs shape (same size in rhsShape).
       int64_t lhsDimIndex = getResultIndex(indexingMaps[0], targetExpr);
       assert(lhsDimIndex >= 0);
       iterationBounds.push_back(lhsShape[lhsDimIndex]);
       continue;
     }
     // Get parallel dimension size from result shape.

 
 //===----------------------------------------------------------------------===//
 // ExtractElementOp
 //===----------------------------------------------------------------------===//
 
 void vector::ExtractElementOp::build(OpBuilder &builder, OperationState &result,
                                      Value source) {
   result.addOperands({source});
-  result.addTypes(source.getType().cast<VectorType>().getElementType());
+  result.addTypes(llvm::cast<VectorType>(source.getType()).getElementType());
 }
 
 LogicalResult vector::ExtractElementOp::verify() {
   VectorType vectorType = getSourceVectorType();
   if (vectorType.getRank() == 0) {
     if (getPosition())
       return emitOpError("expected position to be empty with 0-D vector");
     return success();
OpFoldResult vector::ExtractElementOp::fold(FoldAdaptor adaptor) {
   Attribute pos = adaptor.getPosition();
 
   // Fold extractelement (splat X) -> X.
   if (auto splat = getVector().getDefiningOp<vector::SplatOp>())
     return splat.getInput();
 
   // Fold extractelement(broadcast(X)) -> X.
   if (auto broadcast = getVector().getDefiningOp<vector::BroadcastOp>())
-    if (!broadcast.getSource().getType().isa<VectorType>())
+    if (!llvm::isa<VectorType>(broadcast.getSource().getType()))
       return broadcast.getSource();
 
   if (!pos || !src)
     return {};
 
-  auto srcElements = src.cast<DenseElementsAttr>().getValues<Attribute>();
+  auto srcElements = llvm::cast<DenseElementsAttr>(src).getValues<Attribute>();
 
-  auto attr = pos.dyn_cast<IntegerAttr>();
+  auto attr = llvm::dyn_cast<IntegerAttr>(pos);
   uint64_t posIdx = attr.getInt();
 
   return srcElements[posIdx];
 }
 
 //===----------------------------------------------------------------------===//
 // ExtractOp
 //===----------------------------------------------------------------------===//

 }
 
 LogicalResult
 ExtractOp::inferReturnTypes(MLIRContext *, std::optional<Location>,
                             ValueRange operands, DictionaryAttr attributes,
                             OpaqueProperties properties, RegionRange,
                             SmallVectorImpl<Type> &inferredReturnTypes) {
   ExtractOp::Adaptor op(operands, attributes);
-  auto vectorType = op.getVector().getType().cast<VectorType>();
+  auto vectorType = llvm::cast<VectorType>(op.getVector().getType());
   if (static_cast<int64_t>(op.getPosition().size()) == vectorType.getRank()) {
     inferredReturnTypes.push_back(vectorType.getElementType());
   } else {
     auto n =
         std::min<size_t>(op.getPosition().size(), vectorType.getRank() - 1);
     inferredReturnTypes.push_back(VectorType::get(
         vectorType.getShape().drop_front(n), vectorType.getElementType()));
   }
   return success();
 }
 
 bool ExtractOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   // Allow extracting 1-element vectors instead of scalars.
   auto isCompatible = [](TypeRange l, TypeRange r) {
-    auto vectorType = l.front().dyn_cast<VectorType>();
+    auto vectorType = llvm::dyn_cast<VectorType>(l.front());
     return vectorType && vectorType.getShape().equals({1}) &&
            vectorType.getElementType() == r.front();
   };
   if (l.size() == 1 && r.size() == 1 &&
       (isCompatible(l, r) || isCompatible(r, l)))
     return true;
   return l == r;
 }
 
 LogicalResult vector::ExtractOp::verify() {
   auto positionAttr = getPosition().getValue();
   if (positionAttr.size() >
       static_cast<unsigned>(getSourceVectorType().getRank()))
     return emitOpError(
         "expected position attribute of rank smaller than vector rank");
   for (const auto &en : llvm::enumerate(positionAttr)) {
-    auto attr = en.value().dyn_cast<IntegerAttr>();
+    auto attr = llvm::dyn_cast<IntegerAttr>(en.value());
     if (!attr || attr.getInt() < 0 ||
         attr.getInt() >= getSourceVectorType().getDimSize(en.index()))
       return emitOpError("expected position attribute #")
              << (en.index() + 1)
              << " to be a non-negative integer smaller than the corresponding "
                 "vector dimension";
   }
   return success();

 static Value foldExtractFromBroadcast(ExtractOp extractOp) {
   Operation *defOp = extractOp.getVector().getDefiningOp();
   if (!defOp || !isa<vector::BroadcastOp, SplatOp>(defOp))
     return Value();
   Value source = defOp->getOperand(0);
   if (extractOp.getType() == source.getType())
     return source;
   auto getRank = [](Type type) {
-    return type.isa<VectorType>() ? type.cast<VectorType>().getRank() : 0;
+    return llvm::isa<VectorType>(type) ? llvm::cast<VectorType>(type).getRank()
+                                       : 0;
   };
   // If splat or broadcast from a scalar, just return the source scalar.
   unsigned broadcastSrcRank = getRank(source.getType());
   if (broadcastSrcRank == 0)
     return source;
 
   unsigned extractResultRank = getRank(extractOp.getType());
   if (extractResultRank >= broadcastSrcRank)
     return Value();
   // Check that the dimension of the result haven't been broadcasted.
-  auto extractVecType = extractOp.getType().dyn_cast<VectorType>();
-  auto broadcastVecType = source.getType().dyn_cast<VectorType>();
+  auto extractVecType = llvm::dyn_cast<VectorType>(extractOp.getType());
+  auto broadcastVecType = llvm::dyn_cast<VectorType>(source.getType());
   if (extractVecType && broadcastVecType &&
       extractVecType.getShape() !=
           broadcastVecType.getShape().take_back(extractResultRank))
     return Value();
 
   auto broadcastOp = cast<vector::BroadcastOp>(defOp);
   int64_t rankDiff = broadcastSrcRank - extractResultRank;
   // Detect all the positions that come from "dim-1" broadcasting.
static Value foldExtractFromShapeCast(ExtractOp extractOp) {
   auto shapeCastOp = extractOp.getVector().getDefiningOp<vector::ShapeCastOp>();
   if (!shapeCastOp)
     return Value();
   // Get the nth dimension size starting from lowest dimension.
   auto getDimReverse = [](VectorType type, int64_t n) {
     return type.getShape().take_back(n + 1).front();
   };
   int64_t destinationRank =
-      extractOp.getType().isa<VectorType>()
-          ? extractOp.getType().cast<VectorType>().getRank()
+      llvm::isa<VectorType>(extractOp.getType())
+          ? llvm::cast<VectorType>(extractOp.getType()).getRank()
           : 0;
   if (destinationRank > shapeCastOp.getSourceVectorType().getRank())
     return Value();
   if (destinationRank > 0) {
-    auto destinationType = extractOp.getResult().getType().cast<VectorType>();
+    auto destinationType =
+        llvm::cast<VectorType>(extractOp.getResult().getType());
     for (int64_t i = 0; i < destinationRank; i++) {
       // The lowest dimension of of the destination must match the lowest
       // dimension of the shapecast op source.
       // TODO: This case could be support in a canonicalization pattern.
       if (getDimReverse(shapeCastOp.getSourceVectorType(), i) !=
           getDimReverse(destinationType, i))
         return Value();
     }
while (!sliceOffsets.empty()) {
     size_t lastOffset = sliceOffsets.size() - 1;
     if (sliceOffsets.back() != 0 ||
         extractStridedSliceOp.getType().getDimSize(lastOffset) !=
             extractStridedSliceOp.getSourceVectorType().getDimSize(lastOffset))
       break;
     sliceOffsets.pop_back();
   }
   unsigned destinationRank = 0;
-  if (auto vecType = extractOp.getType().dyn_cast<VectorType>())
+  if (auto vecType = llvm::dyn_cast<VectorType>(extractOp.getType()))
     destinationRank = vecType.getRank();
   // The dimensions of the result need to be untouched by the
   // extractStridedSlice op.
   if (destinationRank > extractStridedSliceOp.getSourceVectorType().getRank() -
                             sliceOffsets.size())
     return Value();
   auto extractedPos = extractVector<int64_t>(extractOp.getPosition());
   assert(extractedPos.size() >= sliceOffsets.size());
   for (size_t i = 0, e = sliceOffsets.size(); i < e; i++)
     extractedPos[i] = extractedPos[i] + sliceOffsets[i];
   extractOp.getVectorMutable().assign(extractStridedSliceOp.getVector());
   // OpBuilder is only used as a helper to build an I64ArrayAttr.
   OpBuilder b(extractOp.getContext());
   extractOp->setAttr(ExtractOp::getPositionAttrStrName(),
                      b.getI64ArrayAttr(extractedPos));
   return extractOp.getResult();
 }
 
 /// Fold extract_op fed from a chain of insertStridedSlice ops.
 static Value foldExtractStridedOpFromInsertChain(ExtractOp op) {
-  int64_t destinationRank = op.getType().isa<VectorType>()
-                                ? op.getType().cast<VectorType>().getRank()
+  int64_t destinationRank = llvm::isa<VectorType>(op.getType())
+                                ? llvm::cast<VectorType>(op.getType()).getRank()
                                 : 0;
   auto insertOp = op.getVector().getDefiningOp<InsertStridedSliceOp>();
   while (insertOp) {
     int64_t insertRankDiff = insertOp.getDestVectorType().getRank() -
                              insertOp.getSourceVectorType().getRank();
     if (destinationRank > insertOp.getSourceVectorType().getRank())
       return Value();
     auto insertOffsets = extractVector<int64_t>(insertOp.getOffsets());
     auto extractOffsets = extractVector<int64_t>(op.getPosition());
 
     if (llvm::any_of(insertOp.getStrides(), [](Attribute attr) {
-          return attr.cast<IntegerAttr>().getInt() != 1;
+          return llvm::cast<IntegerAttr>(attr).getInt() != 1;
         }))
       return Value();
     bool disjoint = false;
     SmallVector<int64_t, 4> offsetDiffs;
     for (unsigned dim = 0, e = extractOffsets.size(); dim < e; ++dim) {
       int64_t start = insertOffsets[dim];
       int64_t size =
           (dim < insertRankDiff)
LogicalResult matchAndRewrite(ExtractOp extractOp,
     Operation *defOp = extractOp.getVector().getDefiningOp();
     if (!defOp || !isa<vector::BroadcastOp, SplatOp>(defOp))
       return failure();
 
     Value source = defOp->getOperand(0);
     if (extractOp.getType() == source.getType())
       return failure();
     auto getRank = [](Type type) {
-      return type.isa<VectorType>() ? type.cast<VectorType>().getRank() : 0;
+      return llvm::isa<VectorType>(type)
+                 ? llvm::cast<VectorType>(type).getRank()
+                 : 0;
     };
     unsigned broadcastSrcRank = getRank(source.getType());
     unsigned extractResultRank = getRank(extractOp.getType());
     // We only consider the case where the rank of the source is less than or
     // equal to the rank of the extract dst. The other cases are handled in the
     // folding patterns.
     if (extractResultRank < broadcastSrcRank)
       return failure();
 
     // Special case if broadcast src is a 0D vector.
     if (extractResultRank == 0) {
-      assert(broadcastSrcRank == 0 && source.getType().isa<VectorType>());
+      assert(broadcastSrcRank == 0 && llvm::isa<VectorType>(source.getType()));
       rewriter.replaceOpWithNewOp<vector::ExtractElementOp>(extractOp, source);
       return success();
     }
     rewriter.replaceOpWithNewOp<vector::BroadcastOp>(
         extractOp, extractOp.getType(), source);
     return success();
   }
 };
 
 // Pattern to rewrite a ExtractOp(splat ConstantOp) -> ConstantOp.
 class ExtractOpSplatConstantFolder final : public OpRewritePattern<ExtractOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(ExtractOp extractOp,
                                 PatternRewriter &rewriter) const override {
     // Return if 'ExtractOp' operand is not defined by a splat vector
     // ConstantOp.
     Value sourceVector = extractOp.getVector();
     Attribute vectorCst;
     if (!matchPattern(sourceVector, m_Constant(&vectorCst)))
       return failure();
-    auto splat = vectorCst.dyn_cast<SplatElementsAttr>();
+    auto splat = llvm::dyn_cast<SplatElementsAttr>(vectorCst);
     if (!splat)
       return failure();
     TypedAttr newAttr = splat.getSplatValue<TypedAttr>();
-    if (auto vecDstType = extractOp.getType().dyn_cast<VectorType>())
+    if (auto vecDstType = llvm::dyn_cast<VectorType>(extractOp.getType()))
       newAttr = DenseElementsAttr::get(vecDstType, newAttr);
     rewriter.replaceOpWithNewOp<arith::ConstantOp>(extractOp, newAttr);
     return success();
   }
 };
 
 // Pattern to rewrite a ExtractOp(non-splat ConstantOp)[...] -> ConstantOp.
 class ExtractOpNonSplatConstantFolder final
     : public OpRewritePattern<ExtractOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(ExtractOp extractOp,
                                 PatternRewriter &rewriter) const override {
     // Return if 'ExtractOp' operand is not defined by a compatible vector
     // ConstantOp.
     Value sourceVector = extractOp.getVector();
     Attribute vectorCst;
     if (!matchPattern(sourceVector, m_Constant(&vectorCst)))
       return failure();
 
-    auto vecTy = sourceVector.getType().cast<VectorType>();
+    auto vecTy = llvm::cast<VectorType>(sourceVector.getType());
     if (vecTy.isScalable())
       return failure();
 
     // The splat case is handled by `ExtractOpSplatConstantFolder`.
-    auto dense = vectorCst.dyn_cast<DenseElementsAttr>();
+    auto dense = llvm::dyn_cast<DenseElementsAttr>(vectorCst);
     if (!dense || dense.isSplat())
       return failure();
 
     // Calculate the linearized position of the continuous chunk of elements to
     // extract.
     llvm::SmallVector<int64_t> completePositions(vecTy.getRank(), 0);
     copy(getI64SubArray(extractOp.getPosition()), completePositions.begin());
     int64_t elemBeginPosition =
         linearize(completePositions, computeStrides(vecTy.getShape()));
     auto denseValuesBegin = dense.value_begin<TypedAttr>() + elemBeginPosition;
 
     TypedAttr newAttr;
-    if (auto resVecTy = extractOp.getType().dyn_cast<VectorType>()) {
+    if (auto resVecTy = llvm::dyn_cast<VectorType>(extractOp.getType())) {
       SmallVector<Attribute> elementValues(
           denseValuesBegin, denseValuesBegin + resVecTy.getNumElements());
       newAttr = DenseElementsAttr::get(resVecTy, elementValues);
     } else {
       newAttr = *denseValuesBegin;
     }
 
     rewriter.replaceOpWithNewOp<arith::ConstantOp>(extractOp, newAttr);
     return success();
   }
 };
 
 } // namespace
 
 void ExtractOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                             MLIRContext *context) {
   results.add<ExtractOpSplatConstantFolder, ExtractOpNonSplatConstantFolder,
               ExtractOpFromBroadcast>(context);
 }
 
 static void populateFromInt64AttrArray(ArrayAttr arrayAttr,
                                        SmallVectorImpl<int64_t> &results) {
   for (auto attr : arrayAttr)
-    results.push_back(attr.cast<IntegerAttr>().getInt());
+    results.push_back(llvm::cast<IntegerAttr>(attr).getInt());
 }
 
 //===----------------------------------------------------------------------===//
 // FmaOp
 //===----------------------------------------------------------------------===//
 
 std::optional<SmallVector<int64_t, 4>> FMAOp::getShapeForUnroll() {
   return llvm::to_vector<4>(getVectorType().getShape());
for (auto [s1, s2] :
     }
     ++dstDim;
   }
   return res;
 }
 
 llvm::SetVector<int64_t> BroadcastOp::computeBroadcastedUnitDims() {
   // Scalar broadcast is without any unit dim broadcast.
-  auto srcVectorType = getSourceType().dyn_cast<VectorType>();
+  auto srcVectorType = llvm::dyn_cast<VectorType>(getSourceType());
   if (!srcVectorType)
     return {};
   return ::computeBroadcastedUnitDims(srcVectorType.getShape(),
                                       getResultVectorType().getShape());
 }
 
 /// Broadcast `value` to a vector of `dstShape`, knowing that exactly the
 /// `broadcastedDims` dimensions in the dstShape are broadcasted.
for (int i = 0, e = dstShape.size(); i < e; ++i) {
     checkShape.push_back(dstShape[i]);
   }
   assert(broadcastedDims.size() == dstShape.size() - checkShape.size() &&
          "ill-formed broadcastedDims contains values not confined to "
          "destVectorShape");
 
   Location loc = value.getLoc();
   Type elementType = getElementTypeOrSelf(value.getType());
-  VectorType srcVectorType = value.getType().dyn_cast<VectorType>();
+  VectorType srcVectorType = llvm::dyn_cast<VectorType>(value.getType());
   VectorType dstVectorType = VectorType::get(dstShape, elementType);
 
   // Step 2. If scalar -> dstShape broadcast, just do it.
   if (!srcVectorType) {
     assert(checkShape.empty() &&
            "ill-formed createOrFoldBroadcastOp arguments");
     return b.createOrFold<vector::BroadcastOp>(loc, dstVectorType, value);
   }

 BroadcastableToResult
 mlir::vector::isBroadcastableTo(Type srcType, VectorType dstVectorType,
                                 std::pair<int, int> *mismatchingDims) {
   // Broadcast scalar to vector of the same element type.
   if (srcType.isIntOrIndexOrFloat() && dstVectorType &&
       getElementTypeOrSelf(srcType) == getElementTypeOrSelf(dstVectorType))
     return BroadcastableToResult::Success;
   // From now on, only vectors broadcast.
-  VectorType srcVectorType = srcType.dyn_cast<VectorType>();
+  VectorType srcVectorType = llvm::dyn_cast<VectorType>(srcType);
   if (!srcVectorType)
     return BroadcastableToResult::SourceTypeNotAVector;
 
   int64_t srcRank = srcVectorType.getRank();
   int64_t dstRank = dstVectorType.getRank();
   if (srcRank > dstRank)
     return BroadcastableToResult::SourceRankHigher;
   // Source has an exact match or singleton value for all trailing dimensions
LogicalResult ShuffleOp::verify() {
   if (maskLength <= 0)
     return emitOpError("invalid mask length");
   if (maskLength != resultType.getDimSize(0))
     return emitOpError("mask length mismatch");
   // Verify all indices.
   int64_t indexSize = (v1Type.getRank() == 0 ? 1 : v1Type.getDimSize(0)) +
                       (v2Type.getRank() == 0 ? 1 : v2Type.getDimSize(0));
   for (const auto &en : llvm::enumerate(maskAttr)) {
-    auto attr = en.value().dyn_cast<IntegerAttr>();
+    auto attr = llvm::dyn_cast<IntegerAttr>(en.value());
     if (!attr || attr.getInt() < 0 || attr.getInt() >= indexSize)
       return emitOpError("mask index #") << (en.index() + 1) << " out of range";
   }
   return success();
 }
 
 LogicalResult
 ShuffleOp::inferReturnTypes(MLIRContext *, std::optional<Location>,
                             ValueRange operands, DictionaryAttr attributes,
                             OpaqueProperties properties, RegionRange,
                             SmallVectorImpl<Type> &inferredReturnTypes) {
   ShuffleOp::Adaptor op(operands, attributes);
-  auto v1Type = op.getV1().getType().cast<VectorType>();
+  auto v1Type = llvm::cast<VectorType>(op.getV1().getType());
   auto v1Rank = v1Type.getRank();
   // Construct resulting type: leading dimension matches mask
   // length, all trailing dimensions match the operands.
   SmallVector<int64_t, 4> shape;
   shape.reserve(v1Rank);
   shape.push_back(std::max<size_t>(1, op.getMask().size()));
   // In the 0-D case there is no trailing shape to append.
   if (v1Rank > 0)
if (!getV1VectorType().isScalable() && !getV2VectorType().isScalable() &&
       isStepIndexArray(getMask(), getV1VectorType().getDimSize(0),
                        getV2VectorType().getDimSize(0)))
     return getV2();
 
   Attribute lhs = adaptor.getV1(), rhs = adaptor.getV2();
   if (!lhs || !rhs)
     return {};
 
-  auto lhsType = lhs.cast<DenseElementsAttr>().getType().cast<VectorType>();
+  auto lhsType =
+      llvm::cast<VectorType>(llvm::cast<DenseElementsAttr>(lhs).getType());
   // Only support 1-D for now to avoid complicated n-D DenseElementsAttr
   // manipulation.
   if (lhsType.getRank() != 1)
     return {};
   int64_t lhsSize = lhsType.getDimSize(0);
 
   SmallVector<Attribute> results;
-  auto lhsElements = lhs.cast<DenseElementsAttr>().getValues<Attribute>();
-  auto rhsElements = rhs.cast<DenseElementsAttr>().getValues<Attribute>();
+  auto lhsElements = llvm::cast<DenseElementsAttr>(lhs).getValues<Attribute>();
+  auto rhsElements = llvm::cast<DenseElementsAttr>(rhs).getValues<Attribute>();
   for (const auto &index : this->getMask().getAsValueRange<IntegerAttr>()) {
     int64_t i = index.getZExtValue();
     if (i >= lhsSize) {
       results.push_back(rhsElements[i - lhsSize]);
     } else {
       results.push_back(lhsElements[i]);
     }
   }
LogicalResult matchAndRewrite(ShuffleOp shuffleOp,
                                 PatternRewriter &rewriter) const override {
     VectorType v1VectorType = shuffleOp.getV1VectorType();
     ArrayAttr mask = shuffleOp.getMask();
     if (v1VectorType.getRank() > 0)
       return failure();
     if (mask.size() != 1)
       return failure();
     Type resType = VectorType::Builder(v1VectorType).setShape({1});
-    if (mask[0].cast<IntegerAttr>().getInt() == 0)
+    if (llvm::cast<IntegerAttr>(mask[0]).getInt() == 0)
       rewriter.replaceOpWithNewOp<vector::BroadcastOp>(shuffleOp, resType,
                                                        shuffleOp.getV1());
     else
       rewriter.replaceOpWithNewOp<vector::BroadcastOp>(shuffleOp, resType,
                                                        shuffleOp.getV2());
     return success();
   }
 };
if (!adaptor.getPosition())
     return {};
 
   Attribute src = adaptor.getSource();
   Attribute dst = adaptor.getDest();
   Attribute pos = adaptor.getPosition();
   if (!src || !dst || !pos)
     return {};
 
-  auto dstElements = dst.cast<DenseElementsAttr>().getValues<Attribute>();
+  auto dstElements = llvm::cast<DenseElementsAttr>(dst).getValues<Attribute>();
 
   SmallVector<Attribute> results(dstElements);
 
-  auto attr = pos.dyn_cast<IntegerAttr>();
+  auto attr = llvm::dyn_cast<IntegerAttr>(pos);
   uint64_t posIdx = attr.getInt();
 
   results[posIdx] = src;
 
   return DenseElementsAttr::get(getDestVectorType(), results);
 }
 
 //===----------------------------------------------------------------------===//

 }
 
 LogicalResult InsertOp::verify() {
   auto positionAttr = getPosition().getValue();
   auto destVectorType = getDestVectorType();
   if (positionAttr.size() > static_cast<unsigned>(destVectorType.getRank()))
     return emitOpError(
         "expected position attribute of rank smaller than dest vector rank");
-  auto srcVectorType = getSourceType().dyn_cast<VectorType>();
+  auto srcVectorType = llvm::dyn_cast<VectorType>(getSourceType());
   if (srcVectorType &&
       (static_cast<unsigned>(srcVectorType.getRank()) + positionAttr.size() !=
        static_cast<unsigned>(destVectorType.getRank())))
     return emitOpError("expected position attribute rank + source rank to "
                        "match dest vector rank");
   if (!srcVectorType &&
       (positionAttr.size() != static_cast<unsigned>(destVectorType.getRank())))
     return emitOpError(
         "expected position attribute rank to match the dest vector rank");
   for (const auto &en : llvm::enumerate(positionAttr)) {
-    auto attr = en.value().dyn_cast<IntegerAttr>();
+    auto attr = llvm::dyn_cast<IntegerAttr>(en.value());
     if (!attr || attr.getInt() < 0 ||
         attr.getInt() >= destVectorType.getDimSize(en.index()))
       return emitOpError("expected position attribute #")
              << (en.index() + 1)
              << " to be a non-negative integer smaller than the corresponding "
                 "dest vector dimension";
   }
   return success();
 }
 
 namespace {
 
 // If insertOp is only inserting unit dimensions it can be transformed to a
 // broadcast.
 class InsertToBroadcast final : public OpRewritePattern<InsertOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(InsertOp insertOp,
                                 PatternRewriter &rewriter) const override {
-    auto srcVecType = insertOp.getSourceType().dyn_cast<VectorType>();
+    auto srcVecType = llvm::dyn_cast<VectorType>(insertOp.getSourceType());
     if (!srcVecType || insertOp.getDestVectorType().getNumElements() !=
                            srcVecType.getNumElements())
       return failure();
     rewriter.replaceOpWithNewOp<BroadcastOp>(
         insertOp, insertOp.getDestVectorType(), insertOp.getSource());
     return success();
   }
 };
LogicalResult matchAndRewrite(InsertOp op,
     if (destTy.isScalable())
       return failure();
 
     // Make sure we do not create too many large constants.
     if (destTy.getNumElements() > vectorSizeFoldThreshold &&
         !destVector.hasOneUse())
       return failure();
 
-    auto denseDest = vectorDestCst.cast<DenseElementsAttr>();
+    auto denseDest = llvm::cast<DenseElementsAttr>(vectorDestCst);
 
     Value sourceValue = op.getSource();
     Attribute sourceCst;
     if (!matchPattern(sourceValue, m_Constant(&sourceCst)))
       return failure();
 
     // Calculate the linearized position of the continuous chunk of elements to
     // insert.
     llvm::SmallVector<int64_t> completePositions(destTy.getRank(), 0);
     copy(getI64SubArray(op.getPosition()), completePositions.begin());
     int64_t insertBeginPosition =
         linearize(completePositions, computeStrides(destTy.getShape()));
 
     SmallVector<Attribute> insertedValues;
-    if (auto denseSource = sourceCst.dyn_cast<DenseElementsAttr>())
+    if (auto denseSource = llvm::dyn_cast<DenseElementsAttr>(sourceCst))
       llvm::append_range(insertedValues, denseSource.getValues<Attribute>());
     else
       insertedValues.push_back(sourceCst);
 
     auto allValues = llvm::to_vector(denseDest.getValues<Attribute>());
     copy(insertedValues, allValues.begin() + insertBeginPosition);
     auto newAttr = DenseElementsAttr::get(destTy, allValues);
 

 // interval. If `halfOpen` is true then the admissible interval is [min, max).
 // Otherwise, the admissible interval is [min, max].
 template <typename OpType>
 static LogicalResult
 isIntegerArrayAttrConfinedToRange(OpType op, ArrayAttr arrayAttr, int64_t min,
                                   int64_t max, StringRef attrName,
                                   bool halfOpen = true) {
   for (auto attr : arrayAttr) {
-    auto val = attr.cast<IntegerAttr>().getInt();
+    auto val = llvm::cast<IntegerAttr>(attr).getInt();
     auto upper = max;
     if (!halfOpen)
       upper += 1;
     if (val < min || val >= upper)
       return op.emitOpError("expected ") << attrName << " to be confined to ["
                                          << min << ", " << upper << ")";
   }
   return success();
 }
 
 // Returns true if all integers in `arrayAttr` are in the half-open [min, max}
 // interval. If `halfOpen` is true then the admissible interval is [min, max).
 // Otherwise, the admissible interval is [min, max].
 template <typename OpType>
 static LogicalResult
 isIntegerArrayAttrConfinedToShape(OpType op, ArrayAttr arrayAttr,
                                   ArrayRef<int64_t> shape, StringRef attrName,
                                   bool halfOpen = true, int64_t min = 0) {
   for (auto [index, attrDimPair] :
        llvm::enumerate(llvm::zip_first(arrayAttr, shape))) {
-    int64_t val =
-        std::get<0>(attrDimPair).template cast<IntegerAttr>().getInt();
+    int64_t val = llvm::cast<IntegerAttr>(std::get<0>(attrDimPair)).getInt();
     int64_t max = std::get<1>(attrDimPair);
     if (!halfOpen)
       max += 1;
     if (val < min || val >= max)
       return op.emitOpError("expected ")
              << attrName << " dimension " << index << " to be confined to ["
              << min << ", " << max << ")";
   }
   return success();
 }
 
 // Returns true if all integers in `arrayAttr` are in the interval [min, max}.
 // interval. If `halfOpen` is true then the admissible interval is [min, max).
 // Otherwise, the admissible interval is [min, max].
 template <typename OpType>
 static LogicalResult isSumOfIntegerArrayAttrConfinedToShape(
     OpType op, ArrayAttr arrayAttr1, ArrayAttr arrayAttr2,
     ArrayRef<int64_t> shape, StringRef attrName1, StringRef attrName2,
     bool halfOpen = true, int64_t min = 1) {
   assert(arrayAttr1.size() <= shape.size());
   assert(arrayAttr2.size() <= shape.size());
   for (auto [index, it] :
        llvm::enumerate(llvm::zip(arrayAttr1, arrayAttr2, shape))) {
-    auto val1 = std::get<0>(it).template cast<IntegerAttr>().getInt();
-    auto val2 = std::get<1>(it).template cast<IntegerAttr>().getInt();
+    auto val1 = llvm::cast<IntegerAttr>(std::get<0>(it)).getInt();
+    auto val2 = llvm::cast<IntegerAttr>(std::get<1>(it)).getInt();
     int64_t max = std::get<2>(it);
     if (!halfOpen)
       max += 1;
     if (val1 + val2 < 0 || val1 + val2 >= max)
       return op.emitOpError("expected sum(")
              << attrName1 << ", " << attrName2 << ") dimension " << index
              << " to be confined to [" << min << ", " << max << ")";
   }
LogicalResult matchAndRewrite(InsertStridedSliceOp op,
     if (destTy.isScalable())
       return failure();
 
     // Make sure we do not create too many large constants.
     if (destTy.getNumElements() > vectorSizeFoldThreshold &&
         !destVector.hasOneUse())
       return failure();
 
-    auto denseDest = vectorDestCst.cast<DenseElementsAttr>();
+    auto denseDest = llvm::cast<DenseElementsAttr>(vectorDestCst);
 
     TypedValue<VectorType> sourceValue = op.getSource();
     Attribute sourceCst;
     if (!matchPattern(sourceValue, m_Constant(&sourceCst)))
       return failure();
 
     // TODO: Handle non-unit strides when they become available.
     if (op.hasNonUnitStrides())
       return failure();
 
     VectorType sliceVecTy = sourceValue.getType();
     ArrayRef<int64_t> sliceShape = sliceVecTy.getShape();
     int64_t rankDifference = destTy.getRank() - sliceVecTy.getRank();
     SmallVector<int64_t, 4> offsets = getI64SubArray(op.getOffsets());
     SmallVector<int64_t, 4> destStrides = computeStrides(destTy.getShape());
 
     // Calcualte the destination element indices by enumerating all slice
     // positions within the destination and linearizing them. The enumeration
     // order is lexicographic which yields a sequence of monotonically
     // increasing linearized position indices.
     // Because the destination may have higher dimensionality then the slice,
     // we keep track of two overlapping sets of positions and offsets.
-    auto denseSlice = sourceCst.cast<DenseElementsAttr>();
+    auto denseSlice = llvm::cast<DenseElementsAttr>(sourceCst);
     auto sliceValuesIt = denseSlice.value_begin<Attribute>();
     auto newValues = llvm::to_vector(denseDest.getValues<Attribute>());
     SmallVector<int64_t> currDestPosition(offsets.begin(), offsets.end());
     MutableArrayRef<int64_t> currSlicePosition(
         currDestPosition.begin() + rankDifference, currDestPosition.end());
     ArrayRef<int64_t> sliceOffsets(offsets.begin() + rankDifference,
                                    offsets.end());
     do {
ParseResult OuterProductOp::parse(OpAsmParser &parser, OperationState &result) {
   if (parser.parseOperandList(operandsInfo) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(tLHS) || parser.parseComma() ||
       parser.parseType(tRHS))
     return failure();
   if (operandsInfo.size() < 2)
     return parser.emitError(parser.getNameLoc(),
                             "expected at least 2 operands");
-  VectorType vLHS = tLHS.dyn_cast<VectorType>();
-  VectorType vRHS = tRHS.dyn_cast<VectorType>();
+  VectorType vLHS = llvm::dyn_cast<VectorType>(tLHS);
+  VectorType vRHS = llvm::dyn_cast<VectorType>(tRHS);
   if (!vLHS)
     return parser.emitError(parser.getNameLoc(),
                             "expected vector type for operand #1");
 
   unsigned numScalableDims = vLHS.getNumScalableDims();
   VectorType resType;
   if (vRHS) {
     numScalableDims += vRHS.getNumScalableDims();
return failure(
       (operandsInfo.size() > 2 &&
        parser.resolveOperand(operandsInfo[2], resType, result.operands)) ||
       parser.addTypeToList(resType, result.types));
 }
 
 LogicalResult OuterProductOp::verify() {
   Type tRHS = getOperandTypeRHS();
   VectorType vLHS = getOperandVectorTypeLHS(),
-             vRHS = tRHS.dyn_cast<VectorType>(),
+             vRHS = llvm::dyn_cast<VectorType>(tRHS),
              vACC = getOperandVectorTypeACC(), vRES = getResultVectorType();
 
   if (vLHS.getRank() != 1)
     return emitOpError("expected 1-d vector for operand #1");
 
   if (vRHS) {
     // Proper OUTER operation.
     if (vRHS.getRank() != 1)

 static Type inferStridedSliceOpResultType(VectorType vectorType,
                                           ArrayAttr offsets, ArrayAttr sizes,
                                           ArrayAttr strides) {
   assert(offsets.size() == sizes.size() && offsets.size() == strides.size());
   SmallVector<int64_t, 4> shape;
   shape.reserve(vectorType.getRank());
   unsigned idx = 0;
   for (unsigned e = offsets.size(); idx < e; ++idx)
-    shape.push_back(sizes[idx].cast<IntegerAttr>().getInt());
+    shape.push_back(llvm::cast<IntegerAttr>(sizes[idx]).getInt());
   for (unsigned e = vectorType.getShape().size(); idx < e; ++idx)
     shape.push_back(vectorType.getShape()[idx]);
 
   return VectorType::get(shape, vectorType.getElementType());
 }
 
 void ExtractStridedSliceOp::build(OpBuilder &builder, OperationState &result,
                                   Value source, ArrayRef<int64_t> offsets,
                                   ArrayRef<int64_t> sizes,
                                   ArrayRef<int64_t> strides) {
   result.addOperands(source);
   auto offsetsAttr = getVectorSubscriptAttr(builder, offsets);
   auto sizesAttr = getVectorSubscriptAttr(builder, sizes);
   auto stridesAttr = getVectorSubscriptAttr(builder, strides);
   result.addTypes(
-      inferStridedSliceOpResultType(source.getType().cast<VectorType>(),
+      inferStridedSliceOpResultType(llvm::cast<VectorType>(source.getType()),
                                     offsetsAttr, sizesAttr, stridesAttr));
   result.addAttribute(getOffsetsAttrStrName(), offsetsAttr);
   result.addAttribute(getSizesAttrStrName(), sizesAttr);
   result.addAttribute(getStridesAttrStrName(), stridesAttr);
 }
 
 LogicalResult ExtractStridedSliceOp::verify() {
   auto type = getSourceVectorType();

 
 // When the source of ExtractStrided comes from a chain of InsertStrided ops try
 // to use the source of the InsertStrided ops if we can detect that the
 // extracted vector is a subset of one of the vector inserted.
 static LogicalResult
 foldExtractStridedOpFromInsertChain(ExtractStridedSliceOp op) {
   // Helper to extract integer out of ArrayAttr.
   auto getElement = [](ArrayAttr array, int idx) {
-    return array[idx].cast<IntegerAttr>().getInt();
+    return llvm::cast<IntegerAttr>(array[idx]).getInt();
   };
   ArrayAttr extractOffsets = op.getOffsets();
   ArrayAttr extractStrides = op.getStrides();
   ArrayAttr extractSizes = op.getSizes();
   auto insertOp = op.getVector().getDefiningOp<InsertStridedSliceOp>();
   while (insertOp) {
     if (op.getSourceVectorType().getRank() !=
         insertOp.getSourceVectorType().getRank())
LogicalResult matchAndRewrite(ExtractStridedSliceOp extractStridedSliceOp,
                                 PatternRewriter &rewriter) const override {
     // Return if 'ExtractStridedSliceOp' operand is not defined by a splat
     // ConstantOp.
     Value sourceVector = extractStridedSliceOp.getVector();
     Attribute vectorCst;
     if (!matchPattern(sourceVector, m_Constant(&vectorCst)))
       return failure();
 
-    auto splat = vectorCst.dyn_cast<SplatElementsAttr>();
+    auto splat = llvm::dyn_cast<SplatElementsAttr>(vectorCst);
     if (!splat)
       return failure();
 
     auto newAttr = SplatElementsAttr::get(extractStridedSliceOp.getType(),
                                           splat.getSplatValue<Attribute>());
     rewriter.replaceOpWithNewOp<arith::ConstantOp>(extractStridedSliceOp,
                                                    newAttr);
     return success();
LogicalResult matchAndRewrite(ExtractStridedSliceOp extractStridedSliceOp,
     // Return if 'ExtractStridedSliceOp' operand is not defined by a non-splat
     // ConstantOp.
     Value sourceVector = extractStridedSliceOp.getVector();
     Attribute vectorCst;
     if (!matchPattern(sourceVector, m_Constant(&vectorCst)))
       return failure();
 
     // The splat case is handled by `StridedSliceSplatConstantFolder`.
-    auto dense = vectorCst.dyn_cast<DenseElementsAttr>();
+    auto dense = llvm::dyn_cast<DenseElementsAttr>(vectorCst);
     if (!dense || dense.isSplat())
       return failure();
 
     // TODO: Handle non-unit strides when they become available.
     if (extractStridedSliceOp.hasNonUnitStrides())
       return failure();
 
-    auto sourceVecTy = sourceVector.getType().cast<VectorType>();
+    auto sourceVecTy = llvm::cast<VectorType>(sourceVector.getType());
     ArrayRef<int64_t> sourceShape = sourceVecTy.getShape();
     SmallVector<int64_t, 4> sourceStrides = computeStrides(sourceShape);
 
     VectorType sliceVecTy = extractStridedSliceOp.getType();
     ArrayRef<int64_t> sliceShape = sliceVecTy.getShape();
     int64_t sliceRank = sliceVecTy.getRank();
 
     // Expand offsets and sizes to match the vector rank.

 public:
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(ExtractStridedSliceOp op,
                                 PatternRewriter &rewriter) const override {
     auto broadcast = op.getVector().getDefiningOp<BroadcastOp>();
     if (!broadcast)
       return failure();
-    auto srcVecType = broadcast.getSource().getType().dyn_cast<VectorType>();
+    auto srcVecType =
+        llvm::dyn_cast<VectorType>(broadcast.getSource().getType());
     unsigned srcRank = srcVecType ? srcVecType.getRank() : 0;
-    auto dstVecType = op.getType().cast<VectorType>();
+    auto dstVecType = llvm::cast<VectorType>(op.getType());
     unsigned dstRank = dstVecType.getRank();
     unsigned rankDiff = dstRank - srcRank;
     // Check if the most inner dimensions of the source of the broadcast are the
     // same as the destination of the extract. If this is the case we can just
     // use a broadcast as the original dimensions are untouched.
     bool lowerDimMatch = true;
     for (unsigned i = 0; i < srcRank; i++) {
       if (srcVecType.getDimSize(i) != dstVecType.getDimSize(i + rankDiff)) {

 // TransferReadOp
 //===----------------------------------------------------------------------===//
 
 /// 1. Builder that sets padding to zero and an empty mask (variant with attrs).
 void TransferReadOp::build(OpBuilder &builder, OperationState &result,
                            VectorType vectorType, Value source,
                            ValueRange indices, AffineMapAttr permutationMapAttr,
                            /*optional*/ ArrayAttr inBoundsAttr) {
-  Type elemType = source.getType().cast<ShapedType>().getElementType();
+  Type elemType = llvm::cast<ShapedType>(source.getType()).getElementType();
   Value padding = builder.create<arith::ConstantOp>(
       result.location, elemType, builder.getZeroAttr(elemType));
   build(builder, result, vectorType, source, indices, permutationMapAttr,
         padding, /*mask=*/Value(), inBoundsAttr);
 }
 
 /// 2. Builder that sets padding to zero an empty mask (variant without attrs).
 void TransferReadOp::build(OpBuilder &builder, OperationState &result,

 }
 
 /// 3. Builder that sets permutation map to 'getMinorIdentityMap'.
 void TransferReadOp::build(OpBuilder &builder, OperationState &result,
                            VectorType vectorType, Value source,
                            ValueRange indices, Value padding,
                            std::optional<ArrayRef<bool>> inBounds) {
   AffineMap permutationMap = getTransferMinorIdentityMap(
-      source.getType().cast<ShapedType>(), vectorType);
+      llvm::cast<ShapedType>(source.getType()), vectorType);
   auto permutationMapAttr = AffineMapAttr::get(permutationMap);
   auto inBoundsAttr = (inBounds && !inBounds.value().empty())
                           ? builder.getBoolArrayAttr(inBounds.value())
                           : ArrayAttr();
   build(builder, result, vectorType, source, indices, permutationMapAttr,
         padding,
         /*mask=*/Value(), inBoundsAttr);
 }
 
 /// 4. Builder that sets padding to zero and permutation map to
 /// 'getMinorIdentityMap'.
 void TransferReadOp::build(OpBuilder &builder, OperationState &result,
                            VectorType vectorType, Value source,
                            ValueRange indices,
                            std::optional<ArrayRef<bool>> inBounds) {
-  Type elemType = source.getType().cast<ShapedType>().getElementType();
+  Type elemType = llvm::cast<ShapedType>(source.getType()).getElementType();
   Value padding = builder.create<arith::ConstantOp>(
       result.location, elemType, builder.getZeroAttr(elemType));
   build(builder, result, vectorType, source, indices, padding, inBounds);
 }
 
 template <typename EmitFun>
 static LogicalResult verifyPermutationMap(AffineMap permutationMap,
                                           EmitFun emitOpError) {
verifyTransferOp(VectorTransferOpInterface op, ShapedType shapedType,
                  VectorType vectorType, VectorType maskType,
                  VectorType inferredMaskType, AffineMap permutationMap,
                  ArrayAttr inBounds) {
   if (op->hasAttr("masked")) {
     return op->emitOpError("masked attribute has been removed. "
                            "Use in_bounds instead.");
   }
 
-  if (!shapedType.isa<MemRefType, RankedTensorType>())
+  if (!llvm::isa<MemRefType, RankedTensorType>(shapedType))
     return op->emitOpError(
         "requires source to be a memref or ranked tensor type");
 
   auto elementType = shapedType.getElementType();
   DataLayout dataLayout = DataLayout::closest(op);
-  if (auto vectorElementType = elementType.dyn_cast<VectorType>()) {
+  if (auto vectorElementType = llvm::dyn_cast<VectorType>(elementType)) {
     // Memref or tensor has vector element type.
     unsigned sourceVecSize =
         dataLayout.getTypeSizeInBits(vectorElementType.getElementType()) *
         vectorElementType.getShape().back();
     unsigned resultVecSize =
         dataLayout.getTypeSizeInBits(vectorType.getElementType()) *
         vectorType.getShape().back();
     if (resultVecSize % sourceVecSize != 0)
verifyTransferOp(VectorTransferOpInterface op, ShapedType shapedType,
   if (inBounds) {
     if (permutationMap.getNumResults() != static_cast<int64_t>(inBounds.size()))
       return op->emitOpError("expects the optional in_bounds attr of same rank "
                              "as permutation_map results: ")
              << AffineMapAttr::get(permutationMap)
              << " vs inBounds of size: " << inBounds.size();
     for (unsigned int i = 0; i < permutationMap.getNumResults(); ++i)
       if (permutationMap.getResult(i).isa<AffineConstantExpr>() &&
-          !inBounds.getValue()[i].cast<BoolAttr>().getValue())
+          !llvm::cast<BoolAttr>(inBounds.getValue()[i]).getValue())
         return op->emitOpError("requires broadcast dimensions to be in-bounds");
   }
 
   return success();
 }
 
 static void printTransferAttrs(OpAsmPrinter &p, VectorTransferOpInterface op) {
   SmallVector<StringRef, 3> elidedAttrs;
   elidedAttrs.push_back(TransferReadOp::getOperandSegmentSizeAttr());
   if (op.permutation_map().isMinorIdentity())
     elidedAttrs.push_back(op.getPermutationMapAttrStrName());
   bool elideInBounds = true;
   if (auto inBounds = op.in_bounds()) {
     for (auto attr : *inBounds) {
-      if (attr.template cast<BoolAttr>().getValue()) {
+      if (llvm::cast<BoolAttr>(attr).getValue()) {
         elideInBounds = false;
         break;
       }
     }
   }
   if (elideInBounds)
     elidedAttrs.push_back(op.getInBoundsAttrStrName());
   p.printOptionalAttrDict(op->getAttrs(), elidedAttrs);
if (parser.parseOperand(maskInfo))
       return failure();
   }
   if (parser.parseOptionalAttrDict(result.attributes) ||
       parser.getCurrentLocation(&typesLoc) || parser.parseColonTypeList(types))
     return failure();
   if (types.size() != 2)
     return parser.emitError(typesLoc, "requires two types");
   auto indexType = builder.getIndexType();
-  auto shapedType = types[0].dyn_cast<ShapedType>();
-  if (!shapedType || !shapedType.isa<MemRefType, RankedTensorType>())
+  auto shapedType = llvm::dyn_cast<ShapedType>(types[0]);
+  if (!shapedType || !llvm::isa<MemRefType, RankedTensorType>(shapedType))
     return parser.emitError(typesLoc, "requires memref or ranked tensor type");
-  VectorType vectorType = types[1].dyn_cast<VectorType>();
+  VectorType vectorType = llvm::dyn_cast<VectorType>(types[1]);
   if (!vectorType)
     return parser.emitError(typesLoc, "requires vector type");
   auto permMapAttrName = TransferReadOp::getPermutationMapAttrStrName();
   Attribute permMapAttr = result.attributes.get(permMapAttrName);
   AffineMap permMap;
   if (!permMapAttr) {
     permMap = getTransferMinorIdentityMap(shapedType, vectorType);
     result.attributes.set(permMapAttrName, AffineMapAttr::get(permMap));
   } else {
-    permMap = permMapAttr.cast<AffineMapAttr>().getValue();
+    permMap = llvm::cast<AffineMapAttr>(permMapAttr).getValue();
   }
   if (parser.resolveOperand(sourceInfo, shapedType, result.operands) ||
       parser.resolveOperands(indexInfo, indexType, result.operands) ||
       parser.resolveOperand(paddingInfo, shapedType.getElementType(),
                             result.operands))
     return failure();
   if (hasMask.succeeded()) {
-    if (shapedType.getElementType().dyn_cast<VectorType>())
+    if (llvm::dyn_cast<VectorType>(shapedType.getElementType()))
       return parser.emitError(
           maskInfo.location, "does not support masks with vector element type");
     // Instead of adding the mask type as an op type, compute it based on the
     // vector type and the permutation map (to keep the type signature small).
     auto maskType = inferTransferOpMaskType(vectorType, permMap);
     if (parser.resolveOperand(maskInfo, maskType, result.operands))
       return failure();
   }
if (static_cast<int64_t>(getIndices().size()) != shapedType.getRank())
     return emitOpError("requires ") << shapedType.getRank() << " indices";
 
   if (failed(verifyTransferOp(cast<VectorTransferOpInterface>(getOperation()),
                               shapedType, vectorType, maskType,
                               inferredMaskType, permutationMap,
                               getInBounds() ? *getInBounds() : ArrayAttr())))
     return failure();
 
-  if (auto sourceVectorElementType = sourceElementType.dyn_cast<VectorType>()) {
+  if (auto sourceVectorElementType =
+          llvm::dyn_cast<VectorType>(sourceElementType)) {
     // Source has vector element type.
     // Check that 'sourceVectorElementType' and 'paddingType' types match.
     if (sourceVectorElementType != paddingType)
       return emitOpError(
           "requires source element type and padding type to match.");
 
   } else {
     // Check that 'paddingType' is valid to store in a vector type.

 ///  %0 = vector.transfer_read %w0[%c1, %c0], %cf0 {in_bounds = [true, true]}
 ///    : tensor<4x4xf32>, vector<1x4xf32>
 ///  ```
 ///  -> Folds into
 ///  ```
 ///  %v0
 ///  ```
 static Value foldRAW(TransferReadOp readOp) {
-  if (!readOp.getShapedType().isa<RankedTensorType>())
+  if (!llvm::isa<RankedTensorType>(readOp.getShapedType()))
     return {};
   auto defWrite = readOp.getSource().getDefiningOp<vector::TransferWriteOp>();
   while (defWrite) {
     if (checkSameValueRAW(defWrite, readOp))
       return defWrite.getVector();
     if (!isDisjointTransferIndices(
             cast<VectorTransferOpInterface>(defWrite.getOperation()),
             cast<VectorTransferOpInterface>(readOp.getOperation())))

 
 std::optional<SmallVector<int64_t, 4>> TransferReadOp::getShapeForUnroll() {
   return llvm::to_vector<4>(getVectorType().getShape());
 }
 
 void TransferReadOp::getEffects(
     SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
         &effects) {
-  if (getShapedType().isa<MemRefType>())
+  if (llvm::isa<MemRefType>(getShapedType()))
     effects.emplace_back(MemoryEffects::Read::get(), getSource(),
                          SideEffects::DefaultResource::get());
 }
 
 /// Returns true if all rank reduced in the given `extractOp` happen in leading
 /// dimensions earlier than last `trailingRank` dimensions.
 static bool areAllRankReducedLeadingDim(tensor::ExtractSliceOp extractOp,
                                         unsigned trailingRank) {

 /// ```
 struct TransferReadAfterWriteToBroadcast
     : public OpRewritePattern<TransferReadOp> {
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(TransferReadOp readOp,
                                 PatternRewriter &rewriter) const override {
     if (readOp.hasOutOfBoundsDim() ||
-        !readOp.getShapedType().isa<RankedTensorType>())
+        !llvm::isa<RankedTensorType>(readOp.getShapedType()))
       return failure();
     auto defWrite = readOp.getSource().getDefiningOp<vector::TransferWriteOp>();
     if (!defWrite)
       return failure();
 
     SmallVector<int64_t> readDims = readOp.getTransferChunkAccessed();
     Value vec;
     if (readOp.getIndices() == defWrite.getIndices() &&

 //===----------------------------------------------------------------------===//
 
 /// 1. Builder with type inference.
 void TransferWriteOp::build(OpBuilder &builder, OperationState &result,
                             Value vector, Value dest, ValueRange indices,
                             AffineMapAttr permutationMapAttr,
                             /*optional*/ Value mask,
                             /*optional*/ ArrayAttr inBoundsAttr) {
-  Type resultType = dest.getType().dyn_cast<RankedTensorType>();
+  Type resultType = llvm::dyn_cast<RankedTensorType>(dest.getType());
   build(builder, result, resultType, vector, dest, indices, permutationMapAttr,
         mask, inBoundsAttr);
 }
 
 /// 2. Builder with type inference that sets an empty mask (variant with attrs).
 void TransferWriteOp::build(OpBuilder &builder, OperationState &result,
                             Value vector, Value dest, ValueRange indices,
                             AffineMapAttr permutationMapAttr,
build(builder, result, vector, dest, indices, permutationMapAttr,
         /*mask=*/Value(), inBoundsAttr);
 }
 
 /// 4. Builder with type inference that sets an empty mask and sets permutation
 ///    map to 'getMinorIdentityMap'.
 void TransferWriteOp::build(OpBuilder &builder, OperationState &result,
                             Value vector, Value dest, ValueRange indices,
                             std::optional<ArrayRef<bool>> inBounds) {
-  auto vectorType = vector.getType().cast<VectorType>();
+  auto vectorType = llvm::cast<VectorType>(vector.getType());
   AffineMap permutationMap = getTransferMinorIdentityMap(
-      dest.getType().cast<ShapedType>(), vectorType);
+      llvm::cast<ShapedType>(dest.getType()), vectorType);
   build(builder, result, vector, dest, indices, permutationMap, inBounds);
 }
 
 ParseResult TransferWriteOp::parse(OpAsmParser &parser,
                                    OperationState &result) {
   auto &builder = parser.getBuilder();
   SMLoc typesLoc;
   OpAsmParser::UnresolvedOperand vectorInfo, sourceInfo;
   SmallVector<OpAsmParser::UnresolvedOperand, 8> indexInfo;
   SmallVector<Type, 2> types;
   OpAsmParser::UnresolvedOperand maskInfo;
   if (parser.parseOperand(vectorInfo) || parser.parseComma() ||
       parser.parseOperand(sourceInfo) ||
       parser.parseOperandList(indexInfo, OpAsmParser::Delimiter::Square))
     return failure();
   ParseResult hasMask = parser.parseOptionalComma();
   if (hasMask.succeeded() && parser.parseOperand(maskInfo))
     return failure();
   if (parser.parseOptionalAttrDict(result.attributes) ||
       parser.getCurrentLocation(&typesLoc) || parser.parseColonTypeList(types))
     return failure();
   if (types.size() != 2)
     return parser.emitError(typesLoc, "requires two types");
   auto indexType = builder.getIndexType();
-  VectorType vectorType = types[0].dyn_cast<VectorType>();
+  VectorType vectorType = llvm::dyn_cast<VectorType>(types[0]);
   if (!vectorType)
     return parser.emitError(typesLoc, "requires vector type");
-  ShapedType shapedType = types[1].dyn_cast<ShapedType>();
-  if (!shapedType || !shapedType.isa<MemRefType, RankedTensorType>())
+  ShapedType shapedType = llvm::dyn_cast<ShapedType>(types[1]);
+  if (!shapedType || !llvm::isa<MemRefType, RankedTensorType>(shapedType))
     return parser.emitError(typesLoc, "requires memref or ranked tensor type");
   auto permMapAttrName = TransferWriteOp::getPermutationMapAttrStrName();
   auto permMapAttr = result.attributes.get(permMapAttrName);
   AffineMap permMap;
   if (!permMapAttr) {
     permMap = getTransferMinorIdentityMap(shapedType, vectorType);
     result.attributes.set(permMapAttrName, AffineMapAttr::get(permMap));
   } else {
-    permMap = permMapAttr.cast<AffineMapAttr>().getValue();
+    permMap = llvm::cast<AffineMapAttr>(permMapAttr).getValue();
   }
   if (parser.resolveOperand(vectorInfo, vectorType, result.operands) ||
       parser.resolveOperand(sourceInfo, shapedType, result.operands) ||
       parser.resolveOperands(indexInfo, indexType, result.operands))
     return failure();
   if (hasMask.succeeded()) {
-    if (shapedType.getElementType().dyn_cast<VectorType>())
+    if (llvm::dyn_cast<VectorType>(shapedType.getElementType()))
       return parser.emitError(
           maskInfo.location, "does not support masks with vector element type");
     auto maskType = inferTransferOpMaskType(vectorType, permMap);
     if (parser.resolveOperand(maskInfo, maskType, result.operands))
       return failure();
   }
   result.addAttribute(TransferWriteOp::getOperandSegmentSizeAttr(),
                       builder.getDenseI32ArrayAttr(
                           {1, 1, static_cast<int32_t>(indexInfo.size()),
                            static_cast<int32_t>(hasMask.succeeded())}));
-  return failure(shapedType.isa<RankedTensorType>() &&
+  return failure(llvm::isa<RankedTensorType>(shapedType) &&
                  parser.addTypeToList(shapedType, result.types));
 }
 
 void TransferWriteOp::print(OpAsmPrinter &p) {
   p << " " << getVector() << ", " << getSource() << "[" << getIndices() << "]";
   if (getMask())
     p << ", " << getMask();
   printTransferAttrs(p, *this);

 /// block argument or has side effects.
 static LogicalResult foldReadInitWrite(TransferWriteOp write,
                                        ArrayRef<Attribute>,
                                        SmallVectorImpl<OpFoldResult> &results) {
   // TODO: support 0-d corner case.
   if (write.getTransferRank() == 0)
     return failure();
   auto rankedTensorType =
-      write.getSource().getType().dyn_cast<RankedTensorType>();
+      llvm::dyn_cast<RankedTensorType>(write.getSource().getType());
   // If not operating on tensors, bail.
   if (!rankedTensorType)
     return failure();
   // If no read, bail.
   auto read = write.getVector().getDefiningOp<vector::TransferReadOp>();
   if (!read)
     return failure();
   // TODO: support 0-d corner case.

 ///
 /// into:
 ///
 /// ```
 ///    %t0
 /// ```
 static LogicalResult foldWAR(TransferWriteOp write,
                              SmallVectorImpl<OpFoldResult> &results) {
-  if (!write.getSource().getType().isa<RankedTensorType>())
+  if (!llvm::isa<RankedTensorType>(write.getSource().getType()))
     return failure();
   auto read = write.getVector().getDefiningOp<vector::TransferReadOp>();
   if (!read)
     return failure();
 
   if (!checkSameValueWAR(read, write))
     return failure();
   results.push_back(read.getSource());

 
 std::optional<SmallVector<int64_t, 4>> TransferWriteOp::getShapeForUnroll() {
   return llvm::to_vector<4>(getVectorType().getShape());
 }
 
 void TransferWriteOp::getEffects(
     SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
         &effects) {
-  if (getShapedType().isa<MemRefType>())
+  if (llvm::isa<MemRefType>(getShapedType()))
     effects.emplace_back(MemoryEffects::Write::get(), getSource(),
                          SideEffects::DefaultResource::get());
 }
 
 namespace {
 /// Remove dead transfer write from the SSA chain so that it an be eliminated by
 /// DCE
 /// ```

 ///
 /// `%w0 = vector.transfer_write` op will be removed by DCE if it doesn't have
 /// any other uses.
 class FoldWaw final : public OpRewritePattern<TransferWriteOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
   LogicalResult matchAndRewrite(TransferWriteOp writeOp,
                                 PatternRewriter &rewriter) const override {
-    if (!writeOp.getShapedType().isa<RankedTensorType>())
+    if (!llvm::isa<RankedTensorType>(writeOp.getShapedType()))
       return failure();
     vector::TransferWriteOp writeToModify = writeOp;
 
     auto defWrite =
         writeOp.getSource().getDefiningOp<vector::TransferWriteOp>();
     while (defWrite) {
       if (checkSameValueWAW(writeOp, defWrite)) {
         rewriter.updateRootInPlace(writeToModify, [&]() {
LogicalResult vector::LoadOp::verify() {
   VectorType resVecTy = getVectorType();
   MemRefType memRefTy = getMemRefType();
 
   if (failed(verifyLoadStoreMemRefLayout(*this, memRefTy)))
     return failure();
 
   // Checks for vector memrefs.
   Type memElemTy = memRefTy.getElementType();
-  if (auto memVecTy = memElemTy.dyn_cast<VectorType>()) {
+  if (auto memVecTy = llvm::dyn_cast<VectorType>(memElemTy)) {
     if (memVecTy != resVecTy)
       return emitOpError("base memref and result vector types should match");
     memElemTy = memVecTy.getElementType();
   }
 
   if (resVecTy.getElementType() != memElemTy)
     return emitOpError("base and result element types should match");
   if (llvm::size(getIndices()) != memRefTy.getRank())
LogicalResult vector::StoreOp::verify() {
   VectorType valueVecTy = getVectorType();
   MemRefType memRefTy = getMemRefType();
 
   if (failed(verifyLoadStoreMemRefLayout(*this, memRefTy)))
     return failure();
 
   // Checks for vector memrefs.
   Type memElemTy = memRefTy.getElementType();
-  if (auto memVecTy = memElemTy.dyn_cast<VectorType>()) {
+  if (auto memVecTy = llvm::dyn_cast<VectorType>(memElemTy)) {
     if (memVecTy != valueVecTy)
       return emitOpError(
           "base memref and valueToStore vector types should match");
     memElemTy = memVecTy.getElementType();
   }
 
   if (valueVecTy.getElementType() != memElemTy)
     return emitOpError("base and valueToStore element type should match");

 //===----------------------------------------------------------------------===//
 
 LogicalResult GatherOp::verify() {
   VectorType indVType = getIndexVectorType();
   VectorType maskVType = getMaskVectorType();
   VectorType resVType = getVectorType();
   ShapedType baseType = getBaseType();
 
-  if (!baseType.isa<MemRefType, RankedTensorType>())
+  if (!llvm::isa<MemRefType, RankedTensorType>(baseType))
     return emitOpError("requires base to be a memref or ranked tensor type");
 
   if (resVType.getElementType() != baseType.getElementType())
     return emitOpError("base and result element type should match");
   if (llvm::size(getIndices()) != baseType.getRank())
     return emitOpError("requires ") << baseType.getRank() << " indices";
   if (resVType.getShape() != indVType.getShape())
     return emitOpError("expected result dim to match indices dim");
static LogicalResult verifyVectorShapeCast(Operation *op,
   } else if (sourceRank > resultRank) {
     if (!isValidShapeCast(resultShape, sourceShape))
       return op->emitOpError("invalid shape cast");
   }
   return success();
 }
 
 LogicalResult ShapeCastOp::verify() {
-  auto sourceVectorType = getSource().getType().dyn_cast_or_null<VectorType>();
-  auto resultVectorType = getResult().getType().dyn_cast_or_null<VectorType>();
+  auto sourceVectorType =
+      llvm::dyn_cast_or_null<VectorType>(getSource().getType());
+  auto resultVectorType =
+      llvm::dyn_cast_or_null<VectorType>(getResult().getType());
 
   // Check if source/result are of vector type.
   if (sourceVectorType && resultVectorType)
     return verifyVectorShapeCast(*this, sourceVectorType, resultVectorType);
 
   return success();
 }
 
 OpFoldResult ShapeCastOp::fold(FoldAdaptor adaptor) {
   // No-op shape cast.
   if (getSource().getType() == getResult().getType())
     return getSource();
 
   // Canceling shape casts.
   if (auto otherOp = getSource().getDefiningOp<ShapeCastOp>()) {
     if (getResult().getType() == otherOp.getSource().getType())
       return otherOp.getSource();
 
     // Only allows valid transitive folding.
-    VectorType srcType = otherOp.getSource().getType().cast<VectorType>();
-    VectorType resultType = getResult().getType().cast<VectorType>();
+    VectorType srcType = llvm::cast<VectorType>(otherOp.getSource().getType());
+    VectorType resultType = llvm::cast<VectorType>(getResult().getType());
     if (srcType.getRank() < resultType.getRank()) {
       if (!isValidShapeCast(srcType.getShape(), resultType.getShape()))
         return {};
     } else if (srcType.getRank() > resultType.getRank()) {
       if (!isValidShapeCast(resultType.getShape(), srcType.getShape()))
         return {};
     } else {
       return {};
public:
 
   LogicalResult matchAndRewrite(ShapeCastOp shapeCastOp,
                                 PatternRewriter &rewriter) const override {
     auto constantOp =
         shapeCastOp.getSource().getDefiningOp<arith::ConstantOp>();
     if (!constantOp)
       return failure();
     // Only handle splat for now.
-    auto dense = constantOp.getValue().dyn_cast<SplatElementsAttr>();
+    auto dense = llvm::dyn_cast<SplatElementsAttr>(constantOp.getValue());
     if (!dense)
       return failure();
     auto newAttr =
-        DenseElementsAttr::get(shapeCastOp.getType().cast<VectorType>(),
+        DenseElementsAttr::get(llvm::cast<VectorType>(shapeCastOp.getType()),
                                dense.getSplatValue<Attribute>());
     rewriter.replaceOpWithNewOp<arith::ConstantOp>(shapeCastOp, newAttr);
     return success();
   }
 };
 
 /// Pattern to rewrite a ShapeCast(Broadcast) -> Broadcast.
 /// This only applies when the shape of the broadcast source is a suffix of the
 /// shape of the result (i.e. when broadcast without reshape is expressive
 /// enough to capture the result in a single op).
 class ShapeCastBroadcastFolder final : public OpRewritePattern<ShapeCastOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(ShapeCastOp shapeCastOp,
                                 PatternRewriter &rewriter) const override {
     auto broadcastOp =
         shapeCastOp.getSource().getDefiningOp<vector::BroadcastOp>();
     if (!broadcastOp)
       return failure();
 
     auto broadcastSourceVectorType =
-        broadcastOp.getSourceType().dyn_cast<VectorType>();
+        llvm::dyn_cast<VectorType>(broadcastOp.getSourceType());
     auto broadcastSourceShape = broadcastSourceVectorType
                                     ? broadcastSourceVectorType.getShape()
                                     : ArrayRef<int64_t>{};
     auto shapeCastTargetShape = shapeCastOp.getResultVectorType().getShape();
 
     // Bail if `broadcastSourceShape` is not a suffix of the result.
     bool isSuffix = (broadcastSourceShape == shapeCastTargetShape.take_back(
                                                  broadcastSourceShape.size()));
OpFoldResult BitCastOp::fold(FoldAdaptor adaptor) {
 
   Attribute sourceConstant = adaptor.getSource();
   if (!sourceConstant)
     return {};
 
   Type srcElemType = getSourceVectorType().getElementType();
   Type dstElemType = getResultVectorType().getElementType();
 
-  if (auto floatPack = sourceConstant.dyn_cast<DenseFPElementsAttr>()) {
+  if (auto floatPack = llvm::dyn_cast<DenseFPElementsAttr>(sourceConstant)) {
     if (floatPack.isSplat()) {
       auto splat = floatPack.getSplatValue<FloatAttr>();
 
       // Casting fp16 into fp32.
       if (srcElemType.isF16() && dstElemType.isF32()) {
         uint32_t bits = static_cast<uint32_t>(
             splat.getValue().bitcastToAPInt().getZExtValue());
         // Duplicate the 16-bit pattern.
         bits = (bits << 16) | (bits & 0xffff);
         APInt intBits(32, bits);
         APFloat floatBits(llvm::APFloat::IEEEsingle(), intBits);
         return DenseElementsAttr::get(getResultVectorType(), floatBits);
       }
     }
   }
 
-  if (auto intPack = sourceConstant.dyn_cast<DenseIntElementsAttr>()) {
+  if (auto intPack = llvm::dyn_cast<DenseIntElementsAttr>(sourceConstant)) {
     if (intPack.isSplat()) {
       auto splat = intPack.getSplatValue<IntegerAttr>();
 
-      if (dstElemType.isa<IntegerType>()) {
+      if (llvm::isa<IntegerType>(dstElemType)) {
         uint64_t srcBitWidth = srcElemType.getIntOrFloatBitWidth();
         uint64_t dstBitWidth = dstElemType.getIntOrFloatBitWidth();
 
         // Casting to a larger integer bit width.
         if (dstBitWidth > srcBitWidth && dstBitWidth % srcBitWidth == 0) {
           APInt intBits = splat.getValue().zext(dstBitWidth);
 
           // Duplicate the lower width element.
           for (uint64_t i = 0; i < dstBitWidth / srcBitWidth - 1; i++)
             intBits = (intBits << srcBitWidth) | intBits;
           return DenseElementsAttr::get(getResultVectorType(), intBits);
         }
       }
     }
   }
 
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // TypeCastOp
 //===----------------------------------------------------------------------===//
 
 static SmallVector<int64_t, 8> extractShape(MemRefType memRefType) {
-  auto vectorType = memRefType.getElementType().dyn_cast<VectorType>();
+  auto vectorType = llvm::dyn_cast<VectorType>(memRefType.getElementType());
   SmallVector<int64_t, 8> res(memRefType.getShape().begin(),
                               memRefType.getShape().end());
   if (vectorType)
     res.append(vectorType.getShape().begin(), vectorType.getShape().end());
   return res;
 }
 
 /// Build the canonical memRefType with a single vector.
 /// E.g. memref<4 x 5 x vector<6 x f32>> -> memref<vector<4 x 5 x 6 x f32>>.
 void TypeCastOp::build(OpBuilder &builder, OperationState &result,
                        Value source) {
   result.addOperands(source);
-  MemRefType memRefType = source.getType().cast<MemRefType>();
+  MemRefType memRefType = llvm::cast<MemRefType>(source.getType());
   VectorType vectorType =
       VectorType::get(extractShape(memRefType),
                       getElementTypeOrSelf(getElementTypeOrSelf(memRefType)));
   result.addTypes(MemRefType::get({}, vectorType, MemRefLayoutAttrInterface(),
                                   memRefType.getMemorySpace()));
 }
 
 LogicalResult TypeCastOp::verify() {

 }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 //===----------------------------------------------------------------------===//
 
 void vector::TransposeOp::build(OpBuilder &builder, OperationState &result,
                                 Value vector, ArrayRef<int64_t> transp) {
-  VectorType vt = vector.getType().cast<VectorType>();
+  VectorType vt = llvm::cast<VectorType>(vector.getType());
   SmallVector<int64_t, 4> transposedShape(vt.getRank());
   for (unsigned i = 0; i < transp.size(); ++i)
     transposedShape[i] = vt.getShape()[transp[i]];
 
   result.addOperands(vector);
   result.addTypes(VectorType::get(transposedShape, vt.getElementType()));
   result.addAttribute(getTranspAttrStrName(), builder.getI64ArrayAttr(transp));
 }
if (vectorType.getRank() != rank)
     return emitOpError("vector result rank mismatch: ") << rank;
   // Verify transposition array.
   auto transpAttr = getTransp().getValue();
   int64_t size = transpAttr.size();
   if (rank != size)
     return emitOpError("transposition length mismatch: ") << size;
   SmallVector<bool, 8> seen(rank, false);
   for (const auto &ta : llvm::enumerate(transpAttr)) {
-    int64_t i = ta.value().cast<IntegerAttr>().getInt();
+    int64_t i = llvm::cast<IntegerAttr>(ta.value()).getInt();
     if (i < 0 || i >= rank)
       return emitOpError("transposition index out of range: ") << i;
     if (seen[i])
       return emitOpError("duplicate position index: ") << i;
     seen[i] = true;
     if (resultType.getDimSize(ta.index()) != vectorType.getDimSize(i))
       return emitOpError("dimension size mismatch at: ") << i;
   }
struct FoldTransposedScalarBroadcast final
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::TransposeOp transposeOp,
                                 PatternRewriter &rewriter) const override {
     auto bcastOp = transposeOp.getVector().getDefiningOp<vector::BroadcastOp>();
     if (!bcastOp)
       return failure();
 
-    auto srcVectorType = bcastOp.getSourceType().dyn_cast<VectorType>();
+    auto srcVectorType = llvm::dyn_cast<VectorType>(bcastOp.getSourceType());
     if (!srcVectorType || srcVectorType.getNumElements() == 1) {
       rewriter.replaceOpWithNewOp<vector::BroadcastOp>(
           transposeOp, transposeOp.getResultVectorType(), bcastOp.getSource());
       return success();
     }
 
     return failure();
   }
void vector::TransposeOp::getTransp(SmallVectorImpl<int64_t> &results) {
   populateFromInt64AttrArray(getTransp(), results);
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantMaskOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult ConstantMaskOp::verify() {
-  auto resultType = getResult().getType().cast<VectorType>();
+  auto resultType = llvm::cast<VectorType>(getResult().getType());
   // Check the corner case of 0-D vectors first.
   if (resultType.getRank() == 0) {
     if (getMaskDimSizes().size() != 1)
       return emitError("array attr must have length 1 for 0-D vectors");
-    auto dim = getMaskDimSizes()[0].cast<IntegerAttr>().getInt();
+    auto dim = llvm::cast<IntegerAttr>(getMaskDimSizes()[0]).getInt();
     if (dim != 0 && dim != 1)
       return emitError("mask dim size must be either 0 or 1 for 0-D vectors");
     return success();
   }
 
   // Verify that array attr size matches the rank of the vector result.
   if (static_cast<int64_t>(getMaskDimSizes().size()) != resultType.getRank())
     return emitOpError(
         "must specify array attr of size equal vector result rank");
   // Verify that each array attr element is in bounds of corresponding vector
   // result dimension size.
   auto resultShape = resultType.getShape();
   SmallVector<int64_t, 4> maskDimSizes;
   for (const auto &it : llvm::enumerate(getMaskDimSizes())) {
-    int64_t attrValue = it.value().cast<IntegerAttr>().getInt();
+    int64_t attrValue = llvm::cast<IntegerAttr>(it.value()).getInt();
     if (attrValue < 0 || attrValue > resultShape[it.index()])
       return emitOpError(
           "array attr of size out of bounds of vector result dimension size");
     maskDimSizes.push_back(attrValue);
   }
   // Verify that if one mask dim size is zero, they all should be zero (because
   // the mask region is a conjunction of each mask dimension interval).
   bool anyZeros = llvm::is_contained(maskDimSizes, 0);
   bool allZeros = llvm::all_of(maskDimSizes, [](int64_t s) { return s == 0; });
   if (anyZeros && !allZeros)
     return emitOpError("expected all mask dim sizes to be zeros, "
                        "as a result of conjunction with zero mask dim");
   // Verify that if the mask type is scalable, dimensions should be zero because
   // constant scalable masks can only be defined for the "none set" or "all set"
   // cases, and there is no VLA way to define an "all set" case for
   // `vector.constant_mask`. In the future, a convention could be established
   // to decide if a specific dimension value could be considered as "all set".
   if (resultType.isScalable() &&
-      getMaskDimSizes()[0].cast<IntegerAttr>().getInt() != 0)
+      llvm::cast<IntegerAttr>(getMaskDimSizes()[0]).getInt() != 0)
     return emitOpError("expected mask dim sizes for scalable masks to be 0");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // CreateMaskOp
 //===----------------------------------------------------------------------===//
 
 void CreateMaskOp::build(OpBuilder &builder, OperationState &result,
                          VectorType type,
                          ArrayRef<OpFoldResult> mixedOperands) {
   SmallVector<Value> operands =
       getValueOrCreateConstantIndexOp(builder, result.location, mixedOperands);
   build(builder, result, type, operands);
 }
 
 LogicalResult CreateMaskOp::verify() {
-  auto vectorType = getResult().getType().cast<VectorType>();
+  auto vectorType = llvm::cast<VectorType>(getResult().getType());
   // Verify that an operand was specified for each result vector each dimension.
   if (vectorType.getRank() == 0) {
     if (getNumOperands() != 1)
       return emitOpError(
           "must specify exactly one operand for 0-D create_mask");
   } else if (getNumOperands() !=
-             getResult().getType().cast<VectorType>().getRank()) {
+             llvm::cast<VectorType>(getResult().getType()).getRank()) {
     return emitOpError(
         "must specify an operand for each result vector dimension");
   }
   return success();
 }
 
 namespace {
 
 // Pattern to rewrite a CreateMaskOp with a ConstantMaskOp.
 class CreateMaskFolder final : public OpRewritePattern<CreateMaskOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(CreateMaskOp createMaskOp,
                                 PatternRewriter &rewriter) const override {
     // Return if any of 'createMaskOp' operands are not defined by a constant.
     auto isNotDefByConstant = [](Value operand) {
       return !isa_and_nonnull<arith::ConstantIndexOp>(operand.getDefiningOp());
     };
     if (llvm::any_of(createMaskOp.getOperands(), isNotDefByConstant))
       return failure();
 
     // CreateMaskOp for scalable vectors can be folded only if all dimensions
     // are negative or zero.
-    if (auto vType = createMaskOp.getType().dyn_cast<VectorType>()) {
+    if (auto vType = llvm::dyn_cast<VectorType>(createMaskOp.getType())) {
       if (vType.isScalable())
         for (auto opDim : createMaskOp.getOperands()) {
           APInt intVal;
           if (matchPattern(opDim, m_ConstantInt(&intVal)) &&
               intVal.isStrictlyPositive())
             return failure();
         }
     }
if (maskableOp->getNumResults() != getNumResults())
     return emitOpError("expects number of results to match maskable operation "
                        "number of results");
 
   if (!llvm::equal(maskableOp->getResultTypes(), getResultTypes()))
     return emitOpError(
         "expects result type to match maskable operation result type");
 
   if (llvm::count_if(maskableOp->getResultTypes(),
-                     [](Type t) { return t.isa<VectorType>(); }) > 1)
+                     [](Type t) { return llvm::isa<VectorType>(t); }) > 1)
     return emitOpError("multiple vector results not supported");
 
   // Mask checks.
   Type expectedMaskType = maskableOp.getExpectedMaskType();
   if (getMask().getType() != expectedMaskType)
     return emitOpError("expects a ")
            << expectedMaskType << " mask for the maskable operation";
 

 // WarpExecuteOnLane0Op
 //===----------------------------------------------------------------------===//
 
 void WarpExecuteOnLane0Op::print(OpAsmPrinter &p) {
   p << "(" << getLaneid() << ")";
 
   SmallVector<StringRef> coreAttr = {getWarpSizeAttrName()};
   auto warpSizeAttr = getOperation()->getAttr(getWarpSizeAttrName());
-  p << "[" << warpSizeAttr.cast<IntegerAttr>().getInt() << "]";
+  p << "[" << llvm::cast<IntegerAttr>(warpSizeAttr).getInt() << "]";
 
   if (!getArgs().empty())
     p << " args(" << getArgs() << " : " << getArgs().getTypes() << ")";
   if (!getResults().empty())
     p << " -> (" << getResults().getTypes() << ')';
   p << " ";
   p.printRegion(getRegion(),
                 /*printEntryBlockArgs=*/true,

 
 /// Helper check if the distributed vector type is consistent with the expanded
 /// type and distributed size.
 static LogicalResult verifyDistributedType(Type expanded, Type distributed,
                                            int64_t warpSize, Operation *op) {
   // If the types matches there is no distribution.
   if (expanded == distributed)
     return success();
-  auto expandedVecType = expanded.dyn_cast<VectorType>();
-  auto distributedVecType = distributed.dyn_cast<VectorType>();
+  auto expandedVecType = llvm::dyn_cast<VectorType>(expanded);
+  auto distributedVecType = llvm::dyn_cast<VectorType>(distributed);
   if (!expandedVecType || !distributedVecType)
     return op->emitOpError("expected vector type for distributed operands.");
   if (expandedVecType.getRank() != distributedVecType.getRank() ||
       expandedVecType.getElementType() != distributedVecType.getElementType())
     return op->emitOpError(
         "expected distributed vectors to have same rank and element type.");
   bool foundDistributedDim = false;
   for (int64_t i = 0, e = expandedVecType.getRank(); i < e; i++) {
Value mlir::vector::makeArithReduction(OpBuilder &b, Location loc,
   Type t1 = getElementTypeOrSelf(v1.getType());
   Type tAcc = getElementTypeOrSelf(acc.getType());
   Value result;
 
   switch (kind) {
   case CombiningKind::ADD:
     if (t1.isIntOrIndex() && tAcc.isIntOrIndex())
       result = b.createOrFold<arith::AddIOp>(loc, v1, acc);
-    else if (t1.isa<FloatType>() && tAcc.isa<FloatType>())
+    else if (llvm::isa<FloatType>(t1) && llvm::isa<FloatType>(tAcc))
       result = b.createOrFold<arith::AddFOp>(loc, v1, acc);
     else
       llvm_unreachable("invalid value types for ADD reduction");
     break;
   case CombiningKind::AND:
     assert(t1.isIntOrIndex() && tAcc.isIntOrIndex() && "expected int values");
     result = b.createOrFold<arith::AndIOp>(loc, v1, acc);
     break;
   case CombiningKind::MAXF:
-    assert(t1.isa<FloatType>() && tAcc.isa<FloatType>() &&
+    assert(llvm::isa<FloatType>(t1) && llvm::isa<FloatType>(tAcc) &&
            "expected float values");
     result = b.createOrFold<arith::MaxFOp>(loc, v1, acc);
     break;
   case CombiningKind::MINF:
-    assert(t1.isa<FloatType>() && tAcc.isa<FloatType>() &&
+    assert(llvm::isa<FloatType>(t1) && llvm::isa<FloatType>(tAcc) &&
            "expected float values");
     result = b.createOrFold<arith::MinFOp>(loc, v1, acc);
     break;
   case CombiningKind::MAXSI:
     assert(t1.isIntOrIndex() && tAcc.isIntOrIndex() && "expected int values");
     result = b.createOrFold<arith::MaxSIOp>(loc, v1, acc);
     break;
   case CombiningKind::MINSI:
     assert(t1.isIntOrIndex() && tAcc.isIntOrIndex() && "expected int values");
     result = b.createOrFold<arith::MinSIOp>(loc, v1, acc);
     break;
   case CombiningKind::MAXUI:
     assert(t1.isIntOrIndex() && tAcc.isIntOrIndex() && "expected int values");
     result = b.createOrFold<arith::MaxUIOp>(loc, v1, acc);
     break;
   case CombiningKind::MINUI:
     assert(t1.isIntOrIndex() && tAcc.isIntOrIndex() && "expected int values");
     result = b.createOrFold<arith::MinUIOp>(loc, v1, acc);
     break;
   case CombiningKind::MUL:
     if (t1.isIntOrIndex() && tAcc.isIntOrIndex())
       result = b.createOrFold<arith::MulIOp>(loc, v1, acc);
-    else if (t1.isa<FloatType>() && tAcc.isa<FloatType>())
+    else if (llvm::isa<FloatType>(t1) && llvm::isa<FloatType>(tAcc))
       result = b.createOrFold<arith::MulFOp>(loc, v1, acc);
     else
       llvm_unreachable("invalid value types for MUL reduction");
     break;
   case CombiningKind::OR:
     assert(t1.isIntOrIndex() && tAcc.isIntOrIndex() && "expected int values");
     result = b.createOrFold<arith::OrIOp>(loc, v1, acc);
     break;

mlir/lib/Dialect/Vector/Transforms/LowerVectorMultiReduction.cpp

if (!useInnerDimsForReduction && vectorShape.size() == 2) {
       std::swap(vectorShape.front(), vectorShape.back());
     }
 
     Value newVectorMask;
     if (maskableOp.isMasked()) {
       Value vectorMask = maskableOp.getMaskingOp().getMask();
       auto maskCastedType = VectorType::get(
           vectorShape,
-          vectorMask.getType().cast<VectorType>().getElementType());
+          llvm::cast<VectorType>(vectorMask.getType()).getElementType());
       newVectorMask =
           rewriter.create<vector::ShapeCastOp>(loc, maskCastedType, vectorMask);
     }
 
     auto castedType = VectorType::get(
         vectorShape, multiReductionOp.getSourceVectorType().getElementType());
     Value cast = rewriter.create<vector::ShapeCastOp>(
         loc, castedType, multiReductionOp.getSource());
LogicalResult matchAndRewrite(vector::MultiDimReductionOp multiReductionOp,
 
     auto loc = multiReductionOp.getLoc();
     auto srcVectorType = multiReductionOp.getSourceVectorType();
     auto srcShape = srcVectorType.getShape();
     auto castedType = VectorType::get(ArrayRef<int64_t>{1, srcShape.back()},
                                       srcVectorType.getElementType());
     auto accType =
         VectorType::get(ArrayRef<int64_t>{1}, srcVectorType.getElementType());
-    assert(!multiReductionOp.getDestType().isa<VectorType>() &&
+    assert(!llvm::isa<VectorType>(multiReductionOp.getDestType()) &&
            "multi_reduction with a single dimension expects a scalar result");
 
     // If the unique dim is reduced and we insert a parallel in front, we need a
     // {false, true} mask.
     SmallVector<bool, 2> reductionMask{false, true};
 
     /// vector.extract(vector.multi_reduce(vector.shape_cast(v, 1xk)), 0)
     Value cast = rewriter.create<vector::ShapeCastOp>(
         loc, castedType, multiReductionOp.getSource());
     Value castAcc = rewriter.create<vector::BroadcastOp>(
         loc, accType, multiReductionOp.getAcc());
     Value castMask;
     if (maskableOp.isMasked()) {
-      auto maskType = mask.getType().cast<ShapedType>();
+      auto maskType = llvm::cast<ShapedType>(mask.getType());
       auto castMaskType =
           VectorType::get(ArrayRef<int64_t>{1, maskType.getShape().back()},
                           maskType.getElementType());
       castMask = rewriter.create<vector::BroadcastOp>(loc, castMaskType, mask);
     }
 
     Operation *newOp = rewriter.create<vector::MultiDimReductionOp>(
         loc, cast, castAcc, reductionMask, multiReductionOp.getKind());

mlir/lib/IR/AffineMap.cpp

case AffineExprKind::FloorDiv:
       return constantFoldBinExpr(
           expr, [](int64_t lhs, int64_t rhs) { return floorDiv(lhs, rhs); });
     case AffineExprKind::CeilDiv:
       return constantFoldBinExpr(
           expr, [](int64_t lhs, int64_t rhs) { return ceilDiv(lhs, rhs); });
     case AffineExprKind::Constant:
       return expr.cast<AffineConstantExpr>().getValue();
     case AffineExprKind::DimId:
-      if (auto attr = operandConsts[expr.cast<AffineDimExpr>().getPosition()]
-                          .dyn_cast_or_null<IntegerAttr>())
+      if (auto attr = llvm::dyn_cast_or_null<IntegerAttr>(
+              operandConsts[expr.cast<AffineDimExpr>().getPosition()]))
         return attr.getInt();
       return std::nullopt;
     case AffineExprKind::SymbolId:
-      if (auto attr = operandConsts[numDims +
-                                    expr.cast<AffineSymbolExpr>().getPosition()]
-                          .dyn_cast_or_null<IntegerAttr>())
+      if (auto attr = llvm::dyn_cast_or_null<IntegerAttr>(
+              operandConsts[numDims +
+                            expr.cast<AffineSymbolExpr>().getPosition()]))
         return attr.getInt();
       return std::nullopt;
     }
     llvm_unreachable("Unknown AffineExpr");
   }
 
   // TODO: Change these to operate on APInts too.
   std::optional<int64_t> constantFoldBinExpr(AffineExpr expr,

mlir/lib/IR/AsmPrinter.cpp

llvm::interleaveComma(op->getOperands(), os, [&](Value operand) {
     *this << (operand ? operand.getType() : Type());
   });
   os << ") -> ";
 
   // Print the result list.  We don't parenthesize single result types unless
   // it is a function (avoiding a grammar ambiguity).
   bool wrapped = op->getNumResults() != 1;
   if (!wrapped && op->getResult(0).getType() &&
-      op->getResult(0).getType().isa<FunctionType>())
+      llvm::isa<FunctionType>(op->getResult(0).getType()))
     wrapped = true;
 
   if (wrapped)
     os << '(';
 
   llvm::interleaveComma(op->getResults(), os, [&](const OpResult &result) {
     // Print the types of null values as <<NULL TYPE>>.
     *this << (result ? result.getType() : Type());
OpPrintingFlags &OpPrintingFlags::printValueUsers() {
   printValueUsersFlag = true;
   return *this;
 }
 
 /// Return if the given ElementsAttr should be elided.
 bool OpPrintingFlags::shouldElideElementsAttr(ElementsAttr attr) const {
   return elementsAttrElementLimit &&
          *elementsAttrElementLimit < int64_t(attr.getNumElements()) &&
-         !attr.isa<SplatElementsAttr>();
+         !llvm::isa<SplatElementsAttr>(attr);
 }
 
 /// Return the size limit for printing large ElementsAttr.
 std::optional<int64_t> OpPrintingFlags::getLargeElementsAttrLimit() const {
   return elementsAttrElementLimit;
 }
 
 /// Return if debug information should be printed.

 private:
   /// Print the given attribute/type, visiting any nested aliases that would be
   /// generated as part of printing.
   void printAndVisitNestedAliasesImpl(Attribute attr, bool elideType) {
     if (!isa<BuiltinDialect>(attr.getDialect())) {
       attr.getDialect().printAttribute(attr, *this);
 
       // Process the builtin attributes.
-    } else if (attr.isa<AffineMapAttr, DenseArrayAttr, FloatAttr, IntegerAttr,
-                        IntegerSetAttr, UnitAttr>()) {
+    } else if (llvm::isa<AffineMapAttr, DenseArrayAttr, FloatAttr, IntegerAttr,
+                         IntegerSetAttr, UnitAttr>(attr)) {
       return;
     } else if (auto dictAttr = dyn_cast<DictionaryAttr>(attr)) {
       for (const NamedAttribute &nestedAttr : dictAttr.getValue()) {
         printAttribute(nestedAttr.getName());
         printAttribute(nestedAttr.getValue());
       }
     } else if (auto arrayAttr = dyn_cast<ArrayAttr>(attr)) {
       for (Attribute nestedAttr : arrayAttr.getValue())
if (!isa<BuiltinDialect>(attr.getDialect())) {
       if (Attribute metadata = locAttr.getMetadata())
         printAttribute(metadata);
       for (Location nestedLoc : locAttr.getLocations())
         printAttribute(nestedLoc);
     }
 
     // Don't print the type if we must elide it, or if it is a None type.
     if (!elideType) {
-      if (auto typedAttr = attr.dyn_cast<TypedAttr>()) {
+      if (auto typedAttr = llvm::dyn_cast<TypedAttr>(attr)) {
         Type attrType = typedAttr.getType();
-        if (!attrType.isa<NoneType>())
+        if (!llvm::isa<NoneType>(attrType))
           printType(attrType);
       }
     }
   }
   void printAndVisitNestedAliasesImpl(Type type) {
     if (!isa<BuiltinDialect>(type.getDialect()))
       return type.getDialect().printType(type, *this);
 
     // Only visit the layout of memref if it isn't the identity.
-    if (auto memrefTy = type.dyn_cast<MemRefType>()) {
+    if (auto memrefTy = llvm::dyn_cast<MemRefType>(type)) {
       printType(memrefTy.getElementType());
       MemRefLayoutAttrInterface layout = memrefTy.getLayout();
-      if (!layout.isa<AffineMapAttr>() || !layout.isIdentity())
+      if (!llvm::isa<AffineMapAttr>(layout) || !layout.isIdentity())
         printAttribute(memrefTy.getLayout());
       if (memrefTy.getMemorySpace())
         printAttribute(memrefTy.getMemorySpace());
       return;
     }
 
     // For most builtin types, we can simply walk the sub elements.
     auto visitFn = [&](auto element) {
for (unsigned i = 0, e = namesToUse.size(); i != e; ++i) {
     // Overwrite the name.
     valueNames[nameToReplace] = name.copy(usedNameAllocator);
   }
 }
 
 void SSANameState::numberValuesInRegion(Region &region) {
   auto setBlockArgNameFn = [&](Value arg, StringRef name) {
     assert(!valueIDs.count(arg) && "arg numbered multiple times");
-    assert(arg.cast<BlockArgument>().getOwner()->getParent() == &region &&
+    assert(llvm::cast<BlockArgument>(arg).getOwner()->getParent() == &region &&
            "arg not defined in current region");
     setValueName(arg, name);
   };
 
   if (!printerFlags.shouldPrintGenericOpForm()) {
     if (Operation *op = region.getParentOp()) {
       if (auto asmInterface = dyn_cast<OpAsmOpInterface>(op))
         asmInterface.getAsmBlockArgumentNames(region, setBlockArgNameFn);
void SSANameState::numberValuesInOp(Operation &op) {
   // Function used to set the special result names for the operation.
   SmallVector<int, 2> resultGroups(/*Size=*/1, /*Value=*/0);
   auto setResultNameFn = [&](Value result, StringRef name) {
     assert(!valueIDs.count(result) && "result numbered multiple times");
     assert(result.getDefiningOp() == &op && "result not defined by 'op'");
     setValueName(result, name);
 
     // Record the result number for groups not anchored at 0.
-    if (int resultNo = result.cast<OpResult>().getResultNumber())
+    if (int resultNo = llvm::cast<OpResult>(result).getResultNumber())
       resultGroups.push_back(resultNo);
   };
   // Operations can customize the printing of block names in OpAsmOpInterface.
   auto setBlockNameFn = [&](Block *block, StringRef name) {
     assert(block->getParentOp() == &op &&
            "getAsmBlockArgumentNames callback invoked on a block not directly "
            "nested under the current operation");
     assert(!blockNames.count(block) && "block numbered multiple times");
TypeSwitch<LocationAttr>(loc)
           printEscapedString(loc.getFilename());
         os << ':' << loc.getLine() << ':' << loc.getColumn();
       })
       .Case<NameLoc>([&](NameLoc loc) {
         printEscapedString(loc.getName());
 
         // Print the child if it isn't unknown.
         auto childLoc = loc.getChildLoc();
-        if (!childLoc.isa<UnknownLoc>()) {
+        if (!llvm::isa<UnknownLoc>(childLoc)) {
           os << '(';
           printLocationInternal(childLoc, pretty);
           os << ')';
         }
       })
       .Case<CallSiteLoc>([&](CallSiteLoc loc) {
         Location caller = loc.getCaller();
         Location callee = loc.getCallee();
         if (!pretty)
           os << "callsite(";
         printLocationInternal(callee, pretty);
         if (pretty) {
-          if (callee.isa<NameLoc>()) {
-            if (caller.isa<FileLineColLoc>()) {
+          if (llvm::isa<NameLoc>(callee)) {
+            if (llvm::isa<FileLineColLoc>(caller)) {
               os << " at ";
             } else {
               os << newLine << " at ";
             }
           } else {
             os << newLine << " at ";
           }
         } else {
if (succeeded(printAlias(attr)))
     return;
   return printAttributeImpl(attr, typeElision);
 }
 
 void AsmPrinter::Impl::printAttributeImpl(Attribute attr,
                                           AttrTypeElision typeElision) {
   if (!isa<BuiltinDialect>(attr.getDialect())) {
     printDialectAttribute(attr);
-  } else if (auto opaqueAttr = attr.dyn_cast<OpaqueAttr>()) {
+  } else if (auto opaqueAttr = llvm::dyn_cast<OpaqueAttr>(attr)) {
     printDialectSymbol(os, "#", opaqueAttr.getDialectNamespace(),
                        opaqueAttr.getAttrData());
-  } else if (attr.isa<UnitAttr>()) {
+  } else if (llvm::isa<UnitAttr>(attr)) {
     os << "unit";
     return;
-  } else if (auto dictAttr = attr.dyn_cast<DictionaryAttr>()) {
+  } else if (auto dictAttr = llvm::dyn_cast<DictionaryAttr>(attr)) {
     os << '{';
     interleaveComma(dictAttr.getValue(),
                     [&](NamedAttribute attr) { printNamedAttribute(attr); });
     os << '}';
 
-  } else if (auto intAttr = attr.dyn_cast<IntegerAttr>()) {
+  } else if (auto intAttr = llvm::dyn_cast<IntegerAttr>(attr)) {
     Type intType = intAttr.getType();
     if (intType.isSignlessInteger(1)) {
       os << (intAttr.getValue().getBoolValue() ? "true" : "false");
 
       // Boolean integer attributes always elides the type.
       return;
     }
 
     // Only print attributes as unsigned if they are explicitly unsigned or are
     // signless 1-bit values.  Indexes, signed values, and multi-bit signless
     // values print as signed.
     bool isUnsigned =
         intType.isUnsignedInteger() || intType.isSignlessInteger(1);
     intAttr.getValue().print(os, !isUnsigned);
 
     // IntegerAttr elides the type if I64.
     if (typeElision == AttrTypeElision::May && intType.isSignlessInteger(64))
       return;
 
-  } else if (auto floatAttr = attr.dyn_cast<FloatAttr>()) {
+  } else if (auto floatAttr = llvm::dyn_cast<FloatAttr>(attr)) {
     printFloatValue(floatAttr.getValue(), os);
 
     // FloatAttr elides the type if F64.
     if (typeElision == AttrTypeElision::May && floatAttr.getType().isF64())
       return;
 
-  } else if (auto strAttr = attr.dyn_cast<StringAttr>()) {
+  } else if (auto strAttr = llvm::dyn_cast<StringAttr>(attr)) {
     printEscapedString(strAttr.getValue());
 
-  } else if (auto arrayAttr = attr.dyn_cast<ArrayAttr>()) {
+  } else if (auto arrayAttr = llvm::dyn_cast<ArrayAttr>(attr)) {
     os << '[';
     interleaveComma(arrayAttr.getValue(), [&](Attribute attr) {
       printAttribute(attr, AttrTypeElision::May);
     });
     os << ']';
 
-  } else if (auto affineMapAttr = attr.dyn_cast<AffineMapAttr>()) {
+  } else if (auto affineMapAttr = llvm::dyn_cast<AffineMapAttr>(attr)) {
     os << "affine_map<";
     affineMapAttr.getValue().print(os);
     os << '>';
 
     // AffineMap always elides the type.
     return;
 
-  } else if (auto integerSetAttr = attr.dyn_cast<IntegerSetAttr>()) {
+  } else if (auto integerSetAttr = llvm::dyn_cast<IntegerSetAttr>(attr)) {
     os << "affine_set<";
     integerSetAttr.getValue().print(os);
     os << '>';
 
     // IntegerSet always elides the type.
     return;
 
-  } else if (auto typeAttr = attr.dyn_cast<TypeAttr>()) {
+  } else if (auto typeAttr = llvm::dyn_cast<TypeAttr>(attr)) {
     printType(typeAttr.getValue());
 
-  } else if (auto refAttr = attr.dyn_cast<SymbolRefAttr>()) {
+  } else if (auto refAttr = llvm::dyn_cast<SymbolRefAttr>(attr)) {
     printSymbolReference(refAttr.getRootReference().getValue(), os);
     for (FlatSymbolRefAttr nestedRef : refAttr.getNestedReferences()) {
       os << "::";
       printSymbolReference(nestedRef.getValue(), os);
     }
 
-  } else if (auto intOrFpEltAttr = attr.dyn_cast<DenseIntOrFPElementsAttr>()) {
+  } else if (auto intOrFpEltAttr =
+                 llvm::dyn_cast<DenseIntOrFPElementsAttr>(attr)) {
     if (printerFlags.shouldElideElementsAttr(intOrFpEltAttr)) {
       printElidedElementsAttr(os);
     } else {
       os << "dense<";
       printDenseIntOrFPElementsAttr(intOrFpEltAttr, /*allowHex=*/true);
       os << '>';
     }
 
-  } else if (auto strEltAttr = attr.dyn_cast<DenseStringElementsAttr>()) {
+  } else if (auto strEltAttr = llvm::dyn_cast<DenseStringElementsAttr>(attr)) {
     if (printerFlags.shouldElideElementsAttr(strEltAttr)) {
       printElidedElementsAttr(os);
     } else {
       os << "dense<";
       printDenseStringElementsAttr(strEltAttr);
       os << '>';
     }
 
-  } else if (auto sparseEltAttr = attr.dyn_cast<SparseElementsAttr>()) {
+  } else if (auto sparseEltAttr = llvm::dyn_cast<SparseElementsAttr>(attr)) {
     if (printerFlags.shouldElideElementsAttr(sparseEltAttr.getIndices()) ||
         printerFlags.shouldElideElementsAttr(sparseEltAttr.getValues())) {
       printElidedElementsAttr(os);
     } else {
       os << "sparse<";
       DenseIntElementsAttr indices = sparseEltAttr.getIndices();
       if (indices.getNumElements() != 0) {
         printDenseIntOrFPElementsAttr(indices, /*allowHex=*/false);
         os << ", ";
         printDenseElementsAttr(sparseEltAttr.getValues(), /*allowHex=*/true);
       }
       os << '>';
     }
-  } else if (auto stridedLayoutAttr = attr.dyn_cast<StridedLayoutAttr>()) {
+  } else if (auto stridedLayoutAttr = llvm::dyn_cast<StridedLayoutAttr>(attr)) {
     stridedLayoutAttr.print(os);
-  } else if (auto denseArrayAttr = attr.dyn_cast<DenseArrayAttr>()) {
+  } else if (auto denseArrayAttr = llvm::dyn_cast<DenseArrayAttr>(attr)) {
     os << "array<";
     printType(denseArrayAttr.getElementType());
     if (!denseArrayAttr.empty()) {
       os << ": ";
       printDenseArrayAttr(denseArrayAttr);
     }
     os << ">";
     return;
-  } else if (auto resourceAttr = attr.dyn_cast<DenseResourceElementsAttr>()) {
+  } else if (auto resourceAttr =
+                 llvm::dyn_cast<DenseResourceElementsAttr>(attr)) {
     os << "dense_resource<";
     printResourceHandle(resourceAttr.getRawHandle());
     os << ">";
-  } else if (auto locAttr = attr.dyn_cast<LocationAttr>()) {
+  } else if (auto locAttr = llvm::dyn_cast<LocationAttr>(attr)) {
     printLocation(locAttr);
   } else {
     llvm::report_fatal_error("Unknown builtin attribute");
   }
   // Don't print the type if we must elide it, or if it is a None type.
   if (typeElision != AttrTypeElision::Must) {
-    if (auto typedAttr = attr.dyn_cast<TypedAttr>()) {
+    if (auto typedAttr = llvm::dyn_cast<TypedAttr>(attr)) {
       Type attrType = typedAttr.getType();
-      if (!attrType.isa<NoneType>()) {
+      if (!llvm::isa<NoneType>(attrType)) {
         os << " : ";
         printType(attrType);
       }
     }
   }
 }
 
 /// Print the integer element of a DenseElementsAttr.
for (unsigned idx = 0, e = numElements; idx != e; ++idx) {
     bumpCounter();
   }
   while (openBrackets-- > 0)
     os << ']';
 }
 
 void AsmPrinter::Impl::printDenseElementsAttr(DenseElementsAttr attr,
                                               bool allowHex) {
-  if (auto stringAttr = attr.dyn_cast<DenseStringElementsAttr>())
+  if (auto stringAttr = llvm::dyn_cast<DenseStringElementsAttr>(attr))
     return printDenseStringElementsAttr(stringAttr);
 
-  printDenseIntOrFPElementsAttr(attr.cast<DenseIntOrFPElementsAttr>(),
+  printDenseIntOrFPElementsAttr(llvm::cast<DenseIntOrFPElementsAttr>(attr),
                                 allowHex);
 }
 
 void AsmPrinter::Impl::printDenseIntOrFPElementsAttr(
     DenseIntOrFPElementsAttr attr, bool allowHex) {
   auto type = attr.getType();
   auto elementType = type.getElementType();
 
if (llvm::support::endian::system_endianness() ==
       printHexString(convRawData);
     } else {
       printHexString(rawData);
     }
 
     return;
   }
 
-  if (ComplexType complexTy = elementType.dyn_cast<ComplexType>()) {
+  if (ComplexType complexTy = llvm::dyn_cast<ComplexType>(elementType)) {
     Type complexElementType = complexTy.getElementType();
     // Note: The if and else below had a common lambda function which invoked
     // printDenseElementsAttrImpl. This lambda was hitting a bug in gcc 9.1,9.2
     // and hence was replaced.
-    if (complexElementType.isa<IntegerType>()) {
+    if (llvm::isa<IntegerType>(complexElementType)) {
       auto valueIt = attr.value_begin<std::complex<APInt>>();
       printDenseElementsAttrImpl(attr.isSplat(), type, os, [&](unsigned index) {
         auto complexValue = *(valueIt + index);
         os << "(";
         printDenseIntElement(complexValue.real(), os, complexElementType);
         os << ",";
         printDenseIntElement(complexValue.imag(), os, complexElementType);
         os << ")";
if (llvm::isa<IntegerType>(complexElementType)) {
       });
     }
   } else if (elementType.isIntOrIndex()) {
     auto valueIt = attr.value_begin<APInt>();
     printDenseElementsAttrImpl(attr.isSplat(), type, os, [&](unsigned index) {
       printDenseIntElement(*(valueIt + index), os, elementType);
     });
   } else {
-    assert(elementType.isa<FloatType>() && "unexpected element type");
+    assert(llvm::isa<FloatType>(elementType) && "unexpected element type");
     auto valueIt = attr.value_begin<APFloat>();
     printDenseElementsAttrImpl(attr.isSplat(), type, os, [&](unsigned index) {
       printFloatValue(*(valueIt + index), os);
     });
   }
 }
 
 void AsmPrinter::Impl::printDenseStringElementsAttr(
if (bitwidth) {
       llvm::LoadIntFromMemory(
           value, reinterpret_cast<const uint8_t *>(data.begin() + byteSize * i),
           byteSize);
     }
     // Print the data as-is or as a float.
     if (type.isIntOrIndex()) {
       printDenseIntElement(value, getStream(), type);
     } else {
-      APFloat fltVal(type.cast<FloatType>().getFloatSemantics(), value);
+      APFloat fltVal(llvm::cast<FloatType>(type).getFloatSemantics(), value);
       printFloatValue(fltVal, getStream());
     }
   };
   llvm::interleaveComma(llvm::seq<unsigned>(0, attr.size()), getStream(),
                         printElementAt);
 }
 
 void AsmPrinter::Impl::printType(Type type) {
TypeSwitch<Type>(type)
           os << 'u';
         os << 'i' << integerTy.getWidth();
       })
       .Case<FunctionType>([&](FunctionType funcTy) {
         os << '(';
         interleaveComma(funcTy.getInputs(), [&](Type ty) { printType(ty); });
         os << ") -> ";
         ArrayRef<Type> results = funcTy.getResults();
-        if (results.size() == 1 && !results[0].isa<FunctionType>()) {
+        if (results.size() == 1 && !llvm::isa<FunctionType>(results[0])) {
           printType(results[0]);
         } else {
           os << '(';
           interleaveComma(results, [&](Type ty) { printType(ty); });
           os << ')';
         }
       })
       .Case<VectorType>([&](VectorType vectorTy) {
TypeSwitch<Type>(type)
           if (ShapedType::isDynamic(dim))
             os << '?';
           else
             os << dim;
           os << 'x';
         }
         printType(memrefTy.getElementType());
         MemRefLayoutAttrInterface layout = memrefTy.getLayout();
-        if (!layout.isa<AffineMapAttr>() || !layout.isIdentity()) {
+        if (!llvm::isa<AffineMapAttr>(layout) || !layout.isIdentity()) {
           os << ", ";
           printAttribute(memrefTy.getLayout(), AttrTypeElision::May);
         }
         // Only print the memory space if it is the non-default one.
         if (memrefTy.getMemorySpace()) {
           os << ", ";
           printAttribute(memrefTy.getMemorySpace(), AttrTypeElision::May);
         }
void AsmPrinter::Impl::printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
   if (!filteredAttrs.empty())
     printFilteredAttributesFn(filteredAttrs);
 }
 void AsmPrinter::Impl::printNamedAttribute(NamedAttribute attr) {
   // Print the name without quotes if possible.
   ::printKeywordOrString(attr.getName().strref(), os);
 
   // Pretty printing elides the attribute value for unit attributes.
-  if (attr.getValue().isa<UnitAttr>())
+  if (llvm::isa<UnitAttr>(attr.getValue()))
     return;
 
   os << " = ";
   printAttribute(attr.getValue());
 }
 
 void AsmPrinter::Impl::printDialectAttribute(Attribute attr) {
   auto &dialect = attr.getDialect();

mlir/lib/IR/AttributeDetail.h

 
 //===----------------------------------------------------------------------===//
 // Elements Attributes
 //===----------------------------------------------------------------------===//
 
 /// Return the bit width which DenseElementsAttr should use for this type.
 inline size_t getDenseElementBitWidth(Type eltType) {
   // Align the width for complex to 8 to make storage and interpretation easier.
-  if (ComplexType comp = eltType.dyn_cast<ComplexType>())
+  if (ComplexType comp = llvm::dyn_cast<ComplexType>(eltType))
     return llvm::alignTo<8>(getDenseElementBitWidth(comp.getElementType())) * 2;
   if (eltType.isIndex())
     return IndexType::kInternalStorageBitWidth;
   return eltType.getIntOrFloatBitWidth();
 }
 
 /// An attribute representing a reference to a dense vector or tensor object.
 struct DenseElementsAttributeStorage : public AttributeStorage {

mlir/lib/IR/Attributes.cpp

 //===----------------------------------------------------------------------===//
 
 NamedAttribute::NamedAttribute(StringAttr name, Attribute value)
     : name(name), value(value) {
   assert(name && value && "expected valid attribute name and value");
   assert(name.size() != 0 && "expected valid attribute name");
 }
 
-StringAttr NamedAttribute::getName() const { return name.cast<StringAttr>(); }
+StringAttr NamedAttribute::getName() const {
+  return llvm::cast<StringAttr>(name);
+}
 
 Dialect *NamedAttribute::getNameDialect() const {
   return getName().getReferencedDialect();
 }
 
 void NamedAttribute::setName(StringAttr newName) {
   assert(name && "expected valid attribute name");
   name = newName;

mlir/lib/IR/Builders.cpp

 
 ArrayAttr Builder::getAffineMapArrayAttr(ArrayRef<AffineMap> values) {
   auto attrs = llvm::to_vector<8>(llvm::map_range(
       values, [](AffineMap v) -> Attribute { return AffineMapAttr::get(v); }));
   return getArrayAttr(attrs);
 }
 
 TypedAttr Builder::getZeroAttr(Type type) {
-  if (type.isa<FloatType>())
+  if (llvm::isa<FloatType>(type))
     return getFloatAttr(type, 0.0);
-  if (type.isa<IndexType>())
+  if (llvm::isa<IndexType>(type))
     return getIndexAttr(0);
-  if (auto integerType = type.dyn_cast<IntegerType>())
-    return getIntegerAttr(type, APInt(type.cast<IntegerType>().getWidth(), 0));
-  if (type.isa<RankedTensorType, VectorType>()) {
-    auto vtType = type.cast<ShapedType>();
+  if (auto integerType = llvm::dyn_cast<IntegerType>(type))
+    return getIntegerAttr(type,
+                          APInt(llvm::cast<IntegerType>(type).getWidth(), 0));
+  if (llvm::isa<RankedTensorType, VectorType>(type)) {
+    auto vtType = llvm::cast<ShapedType>(type);
     auto element = getZeroAttr(vtType.getElementType());
     if (!element)
       return {};
     return DenseElementsAttr::get(vtType, element);
   }
   return {};
 }
 

mlir/lib/IR/BuiltinAttributeInterfaces.cpp

bool ElementsAttr::isValidIndex(ShapedType type, ArrayRef<uint64_t> index) {
   });
 }
 bool ElementsAttr::isValidIndex(ElementsAttr elementsAttr,
                                 ArrayRef<uint64_t> index) {
   return isValidIndex(elementsAttr.getShapedType(), index);
 }
 
 uint64_t ElementsAttr::getFlattenedIndex(Type type, ArrayRef<uint64_t> index) {
-  ShapedType shapeType = type.cast<ShapedType>();
+  ShapedType shapeType = llvm::cast<ShapedType>(type);
   assert(isValidIndex(shapeType, index) &&
          "expected valid multi-dimensional index");
 
   // Reduce the provided multidimensional index into a flattended 1D row-major
   // index.
   auto rank = shapeType.getRank();
   ArrayRef<int64_t> shape = shapeType.getShape();
   uint64_t valueIndex = 0;

mlir/lib/IR/BuiltinAttributes.cpp

value.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
                   &losesInfo);
   }
   return value.convertToDouble();
 }
 
 LogicalResult FloatAttr::verify(function_ref<InFlightDiagnostic()> emitError,
                                 Type type, APFloat value) {
   // Verify that the type is correct.
-  if (!type.isa<FloatType>())
+  if (!llvm::isa<FloatType>(type))
     return emitError() << "expected floating point type";
 
   // Verify that the type semantics match that of the value.
-  if (&type.cast<FloatType>().getFloatSemantics() != &value.getSemantics()) {
+  if (&llvm::cast<FloatType>(type).getFloatSemantics() !=
+      &value.getSemantics()) {
     return emitError()
            << "FloatAttr type doesn't match the type implied by its value";
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolRefAttr
 //===----------------------------------------------------------------------===//
 
 SymbolRefAttr SymbolRefAttr::get(MLIRContext *ctx, StringRef value,
                                  ArrayRef<FlatSymbolRefAttr> nestedRefs) {
   return get(StringAttr::get(ctx, value), nestedRefs);
 }
 
 FlatSymbolRefAttr SymbolRefAttr::get(MLIRContext *ctx, StringRef value) {
-  return get(ctx, value, {}).cast<FlatSymbolRefAttr>();
+  return llvm::cast<FlatSymbolRefAttr>(get(ctx, value, {}));
 }
 
 FlatSymbolRefAttr SymbolRefAttr::get(StringAttr value) {
-  return get(value, {}).cast<FlatSymbolRefAttr>();
+  return llvm::cast<FlatSymbolRefAttr>(get(value, {}));
 }
 
 FlatSymbolRefAttr SymbolRefAttr::get(Operation *symbol) {
   auto symName =
       symbol->getAttrOfType<StringAttr>(SymbolTable::getSymbolAttrName());
   assert(symName && "value does not have a valid symbol name");
   return SymbolRefAttr::get(symName);
 }

 APSInt IntegerAttr::getAPSInt() const {
   assert(!getType().isSignlessInteger() &&
          "Signless integers don't carry a sign for APSInt");
   return APSInt(getValue(), getType().isUnsignedInteger());
 }
 
 LogicalResult IntegerAttr::verify(function_ref<InFlightDiagnostic()> emitError,
                                   Type type, APInt value) {
-  if (IntegerType integerType = type.dyn_cast<IntegerType>()) {
+  if (IntegerType integerType = llvm::dyn_cast<IntegerType>(type)) {
     if (integerType.getWidth() != value.getBitWidth())
       return emitError() << "integer type bit width (" << integerType.getWidth()
                          << ") doesn't match value bit width ("
                          << value.getBitWidth() << ")";
     return success();
   }
-  if (type.isa<IndexType>()) {
+  if (llvm::isa<IndexType>(type)) {
     if (value.getBitWidth() != IndexType::kInternalStorageBitWidth)
       return emitError()
              << "value bit width (" << value.getBitWidth()
              << ") doesn't match index type internal storage bit width ("
              << IndexType::kInternalStorageBitWidth << ")";
     return success();
   }
   return emitError() << "expected integer or index type";
 }
 
 BoolAttr IntegerAttr::getBoolAttrUnchecked(IntegerType type, bool value) {
   auto attr = Base::get(type.getContext(), type, APInt(/*numBits=*/1, value));
-  return attr.cast<BoolAttr>();
+  return llvm::cast<BoolAttr>(attr);
 }
 
 //===----------------------------------------------------------------------===//
 // BoolAttr
 //===----------------------------------------------------------------------===//
 
 bool BoolAttr::getValue() const {
   auto *storage = reinterpret_cast<IntegerAttrStorage *>(impl);
   return storage->value.getBoolValue();
 }
 
 bool BoolAttr::classof(Attribute attr) {
-  IntegerAttr intAttr = attr.dyn_cast<IntegerAttr>();
+  IntegerAttr intAttr = llvm::dyn_cast<IntegerAttr>(attr);
   return intAttr && intAttr.getType().isSignlessInteger(1);
 }
 
 //===----------------------------------------------------------------------===//
 // OpaqueAttr
 //===----------------------------------------------------------------------===//
 
 LogicalResult OpaqueAttr::verify(function_ref<InFlightDiagnostic()> emitError,

 
 DenseElementsAttr::AttributeElementIterator::AttributeElementIterator(
     DenseElementsAttr attr, size_t index)
     : llvm::indexed_accessor_iterator<AttributeElementIterator, const void *,
                                       Attribute, Attribute, Attribute>(
           attr.getAsOpaquePointer(), index) {}
 
 Attribute DenseElementsAttr::AttributeElementIterator::operator*() const {
-  auto owner = getFromOpaquePointer(base).cast<DenseElementsAttr>();
+  auto owner = llvm::cast<DenseElementsAttr>(getFromOpaquePointer(base));
   Type eltTy = owner.getElementType();
-  if (auto intEltTy = eltTy.dyn_cast<IntegerType>())
+  if (auto intEltTy = llvm::dyn_cast<IntegerType>(eltTy))
     return IntegerAttr::get(eltTy, *IntElementIterator(owner, index));
-  if (eltTy.isa<IndexType>())
+  if (llvm::isa<IndexType>(eltTy))
     return IntegerAttr::get(eltTy, *IntElementIterator(owner, index));
-  if (auto floatEltTy = eltTy.dyn_cast<FloatType>()) {
+  if (auto floatEltTy = llvm::dyn_cast<FloatType>(eltTy)) {
     IntElementIterator intIt(owner, index);
     FloatElementIterator floatIt(floatEltTy.getFloatSemantics(), intIt);
     return FloatAttr::get(eltTy, *floatIt);
   }
-  if (auto complexTy = eltTy.dyn_cast<ComplexType>()) {
+  if (auto complexTy = llvm::dyn_cast<ComplexType>(eltTy)) {
     auto complexEltTy = complexTy.getElementType();
     ComplexIntElementIterator complexIntIt(owner, index);
-    if (complexEltTy.isa<IntegerType>()) {
+    if (llvm::isa<IntegerType>(complexEltTy)) {
       auto value = *complexIntIt;
       auto real = IntegerAttr::get(complexEltTy, value.real());
       auto imag = IntegerAttr::get(complexEltTy, value.imag());
       return ArrayAttr::get(complexTy.getContext(),
                             ArrayRef<Attribute>{real, imag});
     }
 
     ComplexFloatElementIterator complexFloatIt(
-        complexEltTy.cast<FloatType>().getFloatSemantics(), complexIntIt);
+        llvm::cast<FloatType>(complexEltTy).getFloatSemantics(), complexIntIt);
     auto value = *complexFloatIt;
     auto real = FloatAttr::get(complexEltTy, value.real());
     auto imag = FloatAttr::get(complexEltTy, value.imag());
     return ArrayAttr::get(complexTy.getContext(),
                           ArrayRef<Attribute>{real, imag});
   }
-  if (owner.isa<DenseStringElementsAttr>()) {
+  if (llvm::isa<DenseStringElementsAttr>(owner)) {
     ArrayRef<StringRef> vals = owner.getRawStringData();
     return StringAttr::get(owner.isSplat() ? vals.front() : vals[index], eltTy);
   }
   llvm_unreachable("unexpected element type");
 }
 
 //===----------------------------------------------------------------------===//
 // BoolElementIterator

 // ComplexIntElementIterator
 
 DenseElementsAttr::ComplexIntElementIterator::ComplexIntElementIterator(
     DenseElementsAttr attr, size_t dataIndex)
     : DenseElementIndexedIteratorImpl<ComplexIntElementIterator,
                                       std::complex<APInt>, std::complex<APInt>,
                                       std::complex<APInt>>(
           attr.getRawData().data(), attr.isSplat(), dataIndex) {
-  auto complexType = attr.getElementType().cast<ComplexType>();
+  auto complexType = llvm::cast<ComplexType>(attr.getElementType());
   bitWidth = getDenseElementBitWidth(complexType.getElementType());
 }
 
 std::complex<APInt>
 DenseElementsAttr::ComplexIntElementIterator::operator*() const {
   size_t storageWidth = getDenseElementStorageWidth(bitWidth);
   size_t offset = getDataIndex() * storageWidth * 2;
   return {readBits(getData(), offset, bitWidth),

 
 namespace {
 /// Instantiations of this class provide utilities for interacting with native
 /// data types in the context of DenseArrayAttr.
 template <size_t width,
           IntegerType::SignednessSemantics signedness = IntegerType::Signless>
 struct DenseArrayAttrIntUtil {
   static bool checkElementType(Type eltType) {
-    auto type = eltType.dyn_cast<IntegerType>();
+    auto type = llvm::dyn_cast<IntegerType>(eltType);
     if (!type || type.getWidth() != width)
       return false;
     return type.getSignedness() == signedness;
   }
 
   static Type getElementType(MLIRContext *ctx) {
     return IntegerType::get(ctx, width, signedness);
   }
DenseArrayAttrImpl<T> DenseArrayAttrImpl<T>::get(MLIRContext *context,
   auto rawArray = ArrayRef<char>(reinterpret_cast<const char *>(content.data()),
                                  content.size() * sizeof(T));
   return llvm::cast<DenseArrayAttrImpl<T>>(
       Base::get(context, elementType, content.size(), rawArray));
 }
 
 template <typename T>
 bool DenseArrayAttrImpl<T>::classof(Attribute attr) {
-  if (auto denseArray = attr.dyn_cast<DenseArrayAttr>())
+  if (auto denseArray = llvm::dyn_cast<DenseArrayAttr>(attr))
     return DenseArrayAttrUtil<T>::checkElementType(denseArray.getElementType());
   return false;
 }
 
 namespace mlir {
 namespace detail {
 // Explicit instantiation for all the supported DenseArrayAttr.
 template class DenseArrayAttrImpl<bool>;
 template class DenseArrayAttrImpl<int8_t>;
 template class DenseArrayAttrImpl<int16_t>;
 template class DenseArrayAttrImpl<int32_t>;
 template class DenseArrayAttrImpl<int64_t>;
 template class DenseArrayAttrImpl<float>;
 template class DenseArrayAttrImpl<double>;
 } // namespace detail
 } // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // DenseElementsAttr
 //===----------------------------------------------------------------------===//
 
 /// Method for support type inquiry through isa, cast and dyn_cast.
 bool DenseElementsAttr::classof(Attribute attr) {
-  return attr.isa<DenseIntOrFPElementsAttr, DenseStringElementsAttr>();
+  return llvm::isa<DenseIntOrFPElementsAttr, DenseStringElementsAttr>(attr);
 }
 
 DenseElementsAttr DenseElementsAttr::get(ShapedType type,
                                          ArrayRef<Attribute> values) {
   assert(hasSameElementsOrSplat(type, values));
 
   Type eltType = type.getElementType();
 
   // Take care complex type case first.
-  if (auto complexType = eltType.dyn_cast<ComplexType>()) {
+  if (auto complexType = llvm::dyn_cast<ComplexType>(eltType)) {
     if (complexType.getElementType().isIntOrIndex()) {
       SmallVector<std::complex<APInt>> complexValues;
       complexValues.reserve(values.size());
       for (Attribute attr : values) {
-        assert(attr.isa<ArrayAttr>() &&
-               "expected ArrayAttr for complex");
-        auto arrayAttr = attr.cast<ArrayAttr>();
+        assert(llvm::isa<ArrayAttr>(attr) && "expected ArrayAttr for complex");
+        auto arrayAttr = llvm::cast<ArrayAttr>(attr);
         assert(arrayAttr.size() == 2 && "expected 2 element for complex");
         auto attr0 = arrayAttr[0];
         auto attr1 = arrayAttr[1];
         complexValues.push_back(
-            std::complex<APInt>(attr0.cast<IntegerAttr>().getValue(),
-                                attr1.cast<IntegerAttr>().getValue()));
+            std::complex<APInt>(llvm::cast<IntegerAttr>(attr0).getValue(),
+                                llvm::cast<IntegerAttr>(attr1).getValue()));
       }
       return DenseElementsAttr::get(type, complexValues);
     }
     // Must be float.
     SmallVector<std::complex<APFloat>> complexValues;
     complexValues.reserve(values.size());
     for (Attribute attr : values) {
-      assert(attr.isa<ArrayAttr>() && "expected ArrayAttr for complex");
-      auto arrayAttr = attr.cast<ArrayAttr>();
+      assert(llvm::isa<ArrayAttr>(attr) && "expected ArrayAttr for complex");
+      auto arrayAttr = llvm::cast<ArrayAttr>(attr);
       assert(arrayAttr.size() == 2 && "expected 2 element for complex");
       auto attr0 = arrayAttr[0];
       auto attr1 = arrayAttr[1];
       complexValues.push_back(
-          std::complex<APFloat>(attr0.cast<FloatAttr>().getValue(),
-                                attr1.cast<FloatAttr>().getValue()));
+          std::complex<APFloat>(llvm::cast<FloatAttr>(attr0).getValue(),
+                                llvm::cast<FloatAttr>(attr1).getValue()));
     }
     return DenseElementsAttr::get(type, complexValues);
   }
 
   // If the element type is not based on int/float/index, assume it is a string
   // type.
   if (!eltType.isIntOrIndexOrFloat()) {
     SmallVector<StringRef, 8> stringValues;
     stringValues.reserve(values.size());
     for (Attribute attr : values) {
-      assert(attr.isa<StringAttr>() &&
+      assert(llvm::isa<StringAttr>(attr) &&
              "expected string value for non integer/index/float element");
-      stringValues.push_back(attr.cast<StringAttr>().getValue());
+      stringValues.push_back(llvm::cast<StringAttr>(attr).getValue());
     }
     return get(type, stringValues);
   }
 
   // Otherwise, get the raw storage width to use for the allocation.
   size_t bitWidth = getDenseElementBitWidth(eltType);
   size_t storageBitWidth = getDenseElementStorageWidth(bitWidth);
 
   // Compress the attribute values into a character buffer.
   SmallVector<char, 8> data(
       llvm::divideCeil(storageBitWidth * values.size(), CHAR_BIT));
   APInt intVal;
   for (unsigned i = 0, e = values.size(); i < e; ++i) {
-    if (auto floatAttr = values[i].dyn_cast<FloatAttr>()) {
+    if (auto floatAttr = llvm::dyn_cast<FloatAttr>(values[i])) {
       assert(floatAttr.getType() == eltType &&
              "expected float attribute type to equal element type");
       intVal = floatAttr.getValue().bitcastToAPInt();
     } else {
-      auto intAttr = values[i].cast<IntegerAttr>();
+      auto intAttr = llvm::cast<IntegerAttr>(values[i]);
       assert(intAttr.getType() == eltType &&
              "expected integer attribute type to equal element type");
       intVal = intAttr.getValue();
     }
 
     assert(intVal.getBitWidth() == bitWidth &&
            "expected value to have same bitwidth as element type");
     writeBits(data.data(), i * storageBitWidth, intVal);
DenseElementsAttr DenseElementsAttr::get(ShapedType type,
                                          ArrayRef<APInt> values) {
   assert(type.getElementType().isIntOrIndex());
   assert(hasSameElementsOrSplat(type, values));
   size_t storageBitWidth = getDenseElementStorageWidth(type.getElementType());
   return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, values);
 }
 DenseElementsAttr DenseElementsAttr::get(ShapedType type,
                                          ArrayRef<std::complex<APInt>> values) {
-  ComplexType complex = type.getElementType().cast<ComplexType>();
-  assert(complex.getElementType().isa<IntegerType>());
+  ComplexType complex = llvm::cast<ComplexType>(type.getElementType());
+  assert(llvm::isa<IntegerType>(complex.getElementType()));
   assert(hasSameElementsOrSplat(type, values));
   size_t storageBitWidth = getDenseElementStorageWidth(complex) / 2;
   ArrayRef<APInt> intVals(reinterpret_cast<const APInt *>(values.data()),
                           values.size() * 2);
   return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, intVals);
 }
 
 // Constructs a dense float elements attribute from an array of APFloat
 // values. Each APFloat value is expected to have the same bitwidth as the
 // element type of 'type'.
 DenseElementsAttr DenseElementsAttr::get(ShapedType type,
                                          ArrayRef<APFloat> values) {
-  assert(type.getElementType().isa<FloatType>());
+  assert(llvm::isa<FloatType>(type.getElementType()));
   assert(hasSameElementsOrSplat(type, values));
   size_t storageBitWidth = getDenseElementStorageWidth(type.getElementType());
   return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, values);
 }
 DenseElementsAttr
 DenseElementsAttr::get(ShapedType type,
                        ArrayRef<std::complex<APFloat>> values) {
-  ComplexType complex = type.getElementType().cast<ComplexType>();
-  assert(complex.getElementType().isa<FloatType>());
+  ComplexType complex = llvm::cast<ComplexType>(type.getElementType());
+  assert(llvm::isa<FloatType>(complex.getElementType()));
   assert(hasSameElementsOrSplat(type, values));
   ArrayRef<APFloat> apVals(reinterpret_cast<const APFloat *>(values.data()),
                            values.size() * 2);
   size_t storageBitWidth = getDenseElementStorageWidth(complex) / 2;
   return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, apVals);
 }
 
 /// Construct a dense elements attribute from a raw buffer representing the
static bool isValidIntOrFloat(Type type, int64_t dataEltSize, bool isInt,
                               bool isSigned) {
   // Make sure that the data element size is the same as the type element width.
   if (getDenseElementBitWidth(type) !=
       static_cast<size_t>(dataEltSize * CHAR_BIT))
     return false;
 
   // Check that the element type is either float or integer or index.
   if (!isInt)
-    return type.isa<FloatType>();
+    return llvm::isa<FloatType>(type);
   if (type.isIndex())
     return true;
 
-  auto intType = type.dyn_cast<IntegerType>();
+  auto intType = llvm::dyn_cast<IntegerType>(type);
   if (!intType)
     return false;
 
   // Make sure signedness semantics is consistent.
   if (intType.isSignless())
     return true;
   return intType.isSigned() ? isSigned : !isSigned;
 }

 
 bool DenseElementsAttr::isValidIntOrFloat(int64_t dataEltSize, bool isInt,
                                           bool isSigned) const {
   return ::isValidIntOrFloat(getElementType(), dataEltSize, isInt, isSigned);
 }
 bool DenseElementsAttr::isValidComplex(int64_t dataEltSize, bool isInt,
                                        bool isSigned) const {
   return ::isValidIntOrFloat(
-      getElementType().cast<ComplexType>().getElementType(), dataEltSize / 2,
-      isInt, isSigned);
+      llvm::cast<ComplexType>(getElementType()).getElementType(),
+      dataEltSize / 2, isInt, isSigned);
 }
 
 /// Returns true if this attribute corresponds to a splat, i.e. if all element
 /// values are the same.
 bool DenseElementsAttr::isSplat() const {
   return static_cast<DenseElementsAttributeStorage *>(impl)->isSplat;
 }
 
 /// Return if the given complex type has an integer element type.
 static bool isComplexOfIntType(Type type) {
-  return type.cast<ComplexType>().getElementType().isa<IntegerType>();
+  return llvm::isa<IntegerType>(llvm::cast<ComplexType>(type).getElementType());
 }
 
 auto DenseElementsAttr::tryGetComplexIntValues() const
     -> FailureOr<iterator_range_impl<ComplexIntElementIterator>> {
   if (!isComplexOfIntType(getElementType()))
     return failure();
   return iterator_range_impl<ComplexIntElementIterator>(
       getType(), ComplexIntElementIterator(*this, 0),
       ComplexIntElementIterator(*this, getNumElements()));
 }
 
 auto DenseElementsAttr::tryGetFloatValues() const
     -> FailureOr<iterator_range_impl<FloatElementIterator>> {
-  auto eltTy = getElementType().dyn_cast<FloatType>();
+  auto eltTy = llvm::dyn_cast<FloatType>(getElementType());
   if (!eltTy)
     return failure();
   const auto &elementSemantics = eltTy.getFloatSemantics();
   return iterator_range_impl<FloatElementIterator>(
       getType(), FloatElementIterator(elementSemantics, raw_int_begin()),
       FloatElementIterator(elementSemantics, raw_int_end()));
 }
 
 auto DenseElementsAttr::tryGetComplexFloatValues() const
     -> FailureOr<iterator_range_impl<ComplexFloatElementIterator>> {
-  auto complexTy = getElementType().dyn_cast<ComplexType>();
+  auto complexTy = llvm::dyn_cast<ComplexType>(getElementType());
   if (!complexTy)
     return failure();
-  auto eltTy = complexTy.getElementType().dyn_cast<FloatType>();
+  auto eltTy = llvm::dyn_cast<FloatType>(complexTy.getElementType());
   if (!eltTy)
     return failure();
   const auto &semantics = eltTy.getFloatSemantics();
   return iterator_range_impl<ComplexFloatElementIterator>(
       getType(), {semantics, {*this, 0}},
       {semantics, {*this, static_cast<size_t>(getNumElements())}});
 }
 

 /// complex type. This method is used to verify type invariants that the
 /// templatized 'get' method cannot.
 DenseElementsAttr DenseIntOrFPElementsAttr::getRawComplex(ShapedType type,
                                                           ArrayRef<char> data,
                                                           int64_t dataEltSize,
                                                           bool isInt,
                                                           bool isSigned) {
   assert(::isValidIntOrFloat(
-      type.getElementType().cast<ComplexType>().getElementType(),
+      llvm::cast<ComplexType>(type.getElementType()).getElementType(),
       dataEltSize / 2, isInt, isSigned));
 
   int64_t numElements = data.size() / dataEltSize;
   (void)numElements;
   assert(numElements == 1 || numElements == type.getNumElements());
   return getRaw(type, data);
 }
 
void DenseIntOrFPElementsAttr::convertEndianOfCharForBEmachine(
   }
 }
 
 void DenseIntOrFPElementsAttr::convertEndianOfArrayRefForBEmachine(
     ArrayRef<char> inRawData, MutableArrayRef<char> outRawData,
     ShapedType type) {
   size_t numElements = type.getNumElements();
   Type elementType = type.getElementType();
-  if (ComplexType complexTy = elementType.dyn_cast<ComplexType>()) {
+  if (ComplexType complexTy = llvm::dyn_cast<ComplexType>(elementType)) {
     elementType = complexTy.getElementType();
     numElements = numElements * 2;
   }
   size_t elementBitWidth = getDenseElementStorageWidth(elementType);
   assert(numElements * elementBitWidth == inRawData.size() * CHAR_BIT &&
          inRawData.size() <= outRawData.size());
   if (elementBitWidth <= CHAR_BIT)
     std::memcpy(outRawData.begin(), inRawData.begin(), inRawData.size());
DenseElementsAttr DenseFPElementsAttr::mapValues(
   auto newArrayType =
       mappingHelper(mapping, *this, getType(), newElementType, elementData);
 
   return getRaw(newArrayType, elementData);
 }
 
 /// Method for supporting type inquiry through isa, cast and dyn_cast.
 bool DenseFPElementsAttr::classof(Attribute attr) {
-  if (auto denseAttr = attr.dyn_cast<DenseElementsAttr>())
-    return denseAttr.getType().getElementType().isa<FloatType>();
+  if (auto denseAttr = llvm::dyn_cast<DenseElementsAttr>(attr))
+    return llvm::isa<FloatType>(denseAttr.getType().getElementType());
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // DenseIntElementsAttr
 //===----------------------------------------------------------------------===//
 
 DenseElementsAttr DenseIntElementsAttr::mapValues(
     Type newElementType, function_ref<APInt(const APInt &)> mapping) const {
   llvm::SmallVector<char, 8> elementData;
   auto newArrayType =
       mappingHelper(mapping, *this, getType(), newElementType, elementData);
   return getRaw(newArrayType, elementData);
 }
 
 /// Method for supporting type inquiry through isa, cast and dyn_cast.
 bool DenseIntElementsAttr::classof(Attribute attr) {
-  if (auto denseAttr = attr.dyn_cast<DenseElementsAttr>())
+  if (auto denseAttr = llvm::dyn_cast<DenseElementsAttr>(attr))
     return denseAttr.getType().getElementType().isIntOrIndex();
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // DenseResourceElementsAttr
 //===----------------------------------------------------------------------===//
 

 namespace {
 /// Instantiations of this class provide utilities for interacting with native
 /// data types in the context of DenseResourceElementsAttr.
 template <typename T>
 struct DenseResourceAttrUtil;
 template <size_t width, bool isSigned>
 struct DenseResourceElementsAttrIntUtil {
   static bool checkElementType(Type eltType) {
-    IntegerType type = eltType.dyn_cast<IntegerType>();
+    IntegerType type = llvm::dyn_cast<IntegerType>(eltType);
     if (!type || type.getWidth() != width)
       return false;
     return isSigned ? !type.isUnsigned() : !type.isSigned();
   }
 };
 template <>
 struct DenseResourceAttrUtil<bool> {
   static bool checkElementType(Type eltType) {
DenseResourceElementsAttrBase<T>::get(ShapedType type, StringRef blobName,
                                       AsmResourceBlob blob) {
   // Check that the blob is in the form we were expecting.
   assert(blob.getDataAlignment() == alignof(T) &&
          "alignment mismatch between expected alignment and blob alignment");
   assert(((blob.getData().size() % sizeof(T)) == 0) &&
          "size mismatch between expected element width and blob size");
   assert(DenseResourceAttrUtil<T>::checkElementType(type.getElementType()) &&
          "invalid shape element type for provided type `T`");
-  return DenseResourceElementsAttr::get(type, blobName, std::move(blob))
-      .template cast<DenseResourceElementsAttrBase<T>>();
+  return llvm::cast<DenseResourceElementsAttrBase<T>>(
+      DenseResourceElementsAttr::get(type, blobName, std::move(blob)));
 }
 
 template <typename T>
 std::optional<ArrayRef<T>>
 DenseResourceElementsAttrBase<T>::tryGetAsArrayRef() const {
   if (AsmResourceBlob *blob = this->getRawHandle().getBlob())
     return blob->template getDataAs<T>();
   return std::nullopt;
 }
 
 template <typename T>
 bool DenseResourceElementsAttrBase<T>::classof(Attribute attr) {
-  auto resourceAttr = attr.dyn_cast<DenseResourceElementsAttr>();
+  auto resourceAttr = llvm::dyn_cast<DenseResourceElementsAttr>(attr);
   return resourceAttr && DenseResourceAttrUtil<T>::checkElementType(
                              resourceAttr.getElementType());
 }
 
 namespace mlir {
 namespace detail {
 // Explicit instantiation for all the supported DenseResourceElementsAttr.
 template class DenseResourceElementsAttrBase<bool>;

 } // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // SparseElementsAttr
 //===----------------------------------------------------------------------===//
 
 /// Get a zero APFloat for the given sparse attribute.
 APFloat SparseElementsAttr::getZeroAPFloat() const {
-  auto eltType = getElementType().cast<FloatType>();
+  auto eltType = llvm::cast<FloatType>(getElementType());
   return APFloat(eltType.getFloatSemantics());
 }
 
 /// Get a zero APInt for the given sparse attribute.
 APInt SparseElementsAttr::getZeroAPInt() const {
-  auto eltType = getElementType().cast<IntegerType>();
+  auto eltType = llvm::cast<IntegerType>(getElementType());
   return APInt::getZero(eltType.getWidth());
 }
 
 /// Get a zero attribute for the given attribute type.
 Attribute SparseElementsAttr::getZeroAttr() const {
   auto eltType = getElementType();
 
   // Handle floating point elements.
-  if (eltType.isa<FloatType>())
+  if (llvm::isa<FloatType>(eltType))
     return FloatAttr::get(eltType, 0);
 
   // Handle complex elements.
-  if (auto complexTy = eltType.dyn_cast<ComplexType>()) {
+  if (auto complexTy = llvm::dyn_cast<ComplexType>(eltType)) {
     auto eltType = complexTy.getElementType();
     Attribute zero;
-    if (eltType.isa<FloatType>())
+    if (llvm::isa<FloatType>(eltType))
       zero = FloatAttr::get(eltType, 0);
     else // must be integer
       zero = IntegerAttr::get(eltType, 0);
     return ArrayAttr::get(complexTy.getContext(),
                           ArrayRef<Attribute>{zero, zero});
   }
 
   // Handle string type.
-  if (getValues().isa<DenseStringElementsAttr>())
+  if (llvm::isa<DenseStringElementsAttr>(getValues()))
     return StringAttr::get("", eltType);
 
   // Otherwise, this is an integer.
   return IntegerAttr::get(eltType, 0);
 }
 
 /// Flatten, and return, all of the sparse indices in this attribute in
 /// row-major order.

mlir/lib/IR/BuiltinDialect.cpp

 
 namespace {
 struct BuiltinOpAsmDialectInterface : public OpAsmDialectInterface {
   BuiltinOpAsmDialectInterface(Dialect *dialect,
                                BuiltinBlobManagerInterface &mgr)
       : OpAsmDialectInterface(dialect), blobManager(mgr) {}
 
   AliasResult getAlias(Attribute attr, raw_ostream &os) const override {
-    if (attr.isa<AffineMapAttr>()) {
+    if (llvm::isa<AffineMapAttr>(attr)) {
       os << "map";
       return AliasResult::OverridableAlias;
     }
-    if (attr.isa<IntegerSetAttr>()) {
+    if (llvm::isa<IntegerSetAttr>(attr)) {
       os << "set";
       return AliasResult::OverridableAlias;
     }
-    if (attr.isa<LocationAttr>()) {
+    if (llvm::isa<LocationAttr>(attr)) {
       os << "loc";
       return AliasResult::OverridableAlias;
     }
     return AliasResult::NoAlias;
   }
 
   AliasResult getAlias(Type type, raw_ostream &os) const final {
-    if (auto tupleType = type.dyn_cast<TupleType>()) {
+    if (auto tupleType = llvm::dyn_cast<TupleType>(type)) {
       if (tupleType.size() > 16) {
         os << "tuple";
         return AliasResult::OverridableAlias;
       }
     }
     return AliasResult::NoAlias;
   }
 
ModuleOp ModuleOp::create(Location loc, std::optional<StringRef> name) {
   return builder.create<ModuleOp>(loc, name);
 }
 
 DataLayoutSpecInterface ModuleOp::getDataLayoutSpec() {
   // Take the first and only (if present) attribute that implements the
   // interface. This needs a linear search, but is called only once per data
   // layout object construction that is used for repeated queries.
   for (NamedAttribute attr : getOperation()->getAttrs())
-    if (auto spec = attr.getValue().dyn_cast<DataLayoutSpecInterface>())
+    if (auto spec = llvm::dyn_cast<DataLayoutSpecInterface>(attr.getValue()))
       return spec;
   return {};
 }
 
 LogicalResult ModuleOp::verify() {
   // Check that none of the attributes are non-dialect attributes, except for
   // the symbol related attributes.
   for (auto attr : (*this)->getAttrs()) {
     if (!attr.getName().strref().contains('.') &&
         !llvm::is_contained(
             ArrayRef<StringRef>{mlir::SymbolTable::getSymbolAttrName(),
                                 mlir::SymbolTable::getVisibilityAttrName()},
             attr.getName().strref()))
       return emitOpError() << "can only contain attributes with "
                               "dialect-prefixed names, found: '"
                            << attr.getName().getValue() << "'";
   }
 
   // Check that there is at most one data layout spec attribute.
   StringRef layoutSpecAttrName;
   DataLayoutSpecInterface layoutSpec;
   for (const NamedAttribute &na : (*this)->getAttrs()) {
-    if (auto spec = na.getValue().dyn_cast<DataLayoutSpecInterface>()) {
+    if (auto spec = llvm::dyn_cast<DataLayoutSpecInterface>(na.getValue())) {
       if (layoutSpec) {
         InFlightDiagnostic diag =
             emitOpError() << "expects at most one data layout attribute";
         diag.attachNote() << "'" << layoutSpecAttrName
                           << "' is a data layout attribute";
         diag.attachNote() << "'" << na.getName().getValue()
                           << "' is a data layout attribute";
       }

mlir/lib/IR/BuiltinDialectBytecode.cpp

 // Utility functions
 
 // TODO: Move these to separate file.
 
 // Returns the bitwidth if known, else return 0.
 static unsigned getIntegerBitWidth(DialectBytecodeReader &reader, Type type) {
   if (auto intType = dyn_cast<IntegerType>(type)) {
     return intType.getWidth();
-  } else if (type.isa<IndexType>()) {
+  } else if (llvm::isa<IndexType>(type)) {
     return IndexType::kInternalStorageBitWidth;
   }
   reader.emitError()
       << "expected integer or index type for IntegerAttr, but got: " << type;
   return 0;
 }
 
 static LogicalResult readAPIntWithKnownWidth(DialectBytecodeReader &reader,

mlir/lib/IR/BuiltinTypes.cpp

return emitError()
            << shape;
 
   return success();
 }
 
 VectorType VectorType::scaleElementBitwidth(unsigned scale) {
   if (!scale)
     return VectorType();
-  if (auto et = getElementType().dyn_cast<IntegerType>())
+  if (auto et = llvm::dyn_cast<IntegerType>(getElementType()))
     if (auto scaledEt = et.scaleElementBitwidth(scale))
       return VectorType::get(getShape(), scaledEt, getNumScalableDims());
-  if (auto et = getElementType().dyn_cast<FloatType>())
+  if (auto et = llvm::dyn_cast<FloatType>(getElementType()))
     if (auto scaledEt = et.scaleElementBitwidth(scale))
       return VectorType::get(getShape(), scaledEt, getNumScalableDims());
   return VectorType();
 }
 
 VectorType VectorType::cloneWith(std::optional<ArrayRef<int64_t>> shape,
                                  Type elementType) const {
   return VectorType::get(shape.value_or(getShape()), elementType,
checkTensorElementType(function_ref<InFlightDiagnostic()> emitError,
   return success();
 }
 
 /// Return true if the specified element type is ok in a tensor.
 bool TensorType::isValidElementType(Type type) {
   // Note: Non standard/builtin types are allowed to exist within tensor
   // types. Dialects are expected to verify that tensor types have a valid
   // element type within that dialect.
-  return type.isa<ComplexType, FloatType, IntegerType, OpaqueType, VectorType,
-                  IndexType>() ||
+  return llvm::isa<ComplexType, FloatType, IntegerType, OpaqueType, VectorType,
+                   IndexType>(type) ||
          !llvm::isa<BuiltinDialect>(type.getDialect());
 }
 
 //===----------------------------------------------------------------------===//
 // RankedTensorType
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 RankedTensorType::verify(function_ref<InFlightDiagnostic()> emitError,
                          ArrayRef<int64_t> shape, Type elementType,
                          Attribute encoding) {
   for (int64_t s : shape)
     if (s < 0 && !ShapedType::isDynamic(s))
       return emitError() << "invalid tensor dimension size";
-  if (auto v = encoding.dyn_cast_or_null<VerifiableTensorEncoding>())
+  if (auto v = llvm::dyn_cast_or_null<VerifiableTensorEncoding>(encoding))
     if (failed(v.verifyEncoding(shape, elementType, emitError)))
       return failure();
   return checkTensorElementType(emitError, elementType);
 }
 
 //===----------------------------------------------------------------------===//
 // UnrankedTensorType
 //===----------------------------------------------------------------------===//

 }
 
 SliceVerificationResult
 mlir::isRankReducedType(ShapedType originalType,
                         ShapedType candidateReducedType) {
   if (originalType == candidateReducedType)
     return SliceVerificationResult::Success;
 
-  ShapedType originalShapedType = originalType.cast<ShapedType>();
+  ShapedType originalShapedType = llvm::cast<ShapedType>(originalType);
   ShapedType candidateReducedShapedType =
-      candidateReducedType.cast<ShapedType>();
+      llvm::cast<ShapedType>(candidateReducedType);
 
   // Rank and size logic is valid for all ShapedTypes.
   ArrayRef<int64_t> originalShape = originalShapedType.getShape();
   ArrayRef<int64_t> candidateReducedShape =
       candidateReducedShapedType.getShape();
   unsigned originalRank = originalShape.size(),
            candidateReducedRank = candidateReducedShape.size();
   if (candidateReducedRank > originalRank)

 }
 
 bool mlir::detail::isSupportedMemorySpace(Attribute memorySpace) {
   // Empty attribute is allowed as default memory space.
   if (!memorySpace)
     return true;
 
   // Supported built-in attributes.
-  if (memorySpace.isa<IntegerAttr, StringAttr, DictionaryAttr>())
+  if (llvm::isa<IntegerAttr, StringAttr, DictionaryAttr>(memorySpace))
     return true;
 
   // Allow custom dialect attributes.
   if (!isa<BuiltinDialect>(memorySpace.getDialect()))
     return true;
 
   return false;
 }
 
 Attribute mlir::detail::wrapIntegerMemorySpace(unsigned memorySpace,
                                                MLIRContext *ctx) {
   if (memorySpace == 0)
     return nullptr;
 
   return IntegerAttr::get(IntegerType::get(ctx, 64), memorySpace);
 }
 
 Attribute mlir::detail::skipDefaultMemorySpace(Attribute memorySpace) {
-  IntegerAttr intMemorySpace = memorySpace.dyn_cast_or_null<IntegerAttr>();
+  IntegerAttr intMemorySpace = llvm::dyn_cast_or_null<IntegerAttr>(memorySpace);
   if (intMemorySpace && intMemorySpace.getValue() == 0)
     return nullptr;
 
   return memorySpace;
 }
 
 unsigned mlir::detail::getMemorySpaceAsInt(Attribute memorySpace) {
   if (!memorySpace)
     return 0;
 
-  assert(memorySpace.isa<IntegerAttr>() &&
+  assert(llvm::isa<IntegerAttr>(memorySpace) &&
          "Using `getMemorySpaceInteger` with non-Integer attribute");
 
-  return static_cast<unsigned>(memorySpace.cast<IntegerAttr>().getInt());
+  return static_cast<unsigned>(llvm::cast<IntegerAttr>(memorySpace).getInt());
 }
 
 unsigned MemRefType::getMemorySpaceAsInt() const {
   return detail::getMemorySpaceAsInt(getMemorySpace());
 }
 
 MemRefType MemRefType::get(ArrayRef<int64_t> shape, Type elementType,
                            MemRefLayoutAttrInterface layout,
static LogicalResult getStridesAndOffset(MemRefType t,
 
   return success();
 }
 
 LogicalResult mlir::getStridesAndOffset(MemRefType t,
                                         SmallVectorImpl<int64_t> &strides,
                                         int64_t &offset) {
   // Happy path: the type uses the strided layout directly.
-  if (auto strided = t.getLayout().dyn_cast<StridedLayoutAttr>()) {
+  if (auto strided = llvm::dyn_cast<StridedLayoutAttr>(t.getLayout())) {
     llvm::append_range(strides, strided.getStrides());
     offset = strided.getOffset();
     return success();
   }
 
   // Otherwise, defer to the affine fallback as layouts are supposed to be
   // convertible to affine maps.
   AffineExpr offsetExpr;

 ArrayRef<Type> TupleType::getTypes() const { return getImpl()->getTypes(); }
 
 /// Accumulate the types contained in this tuple and tuples nested within it.
 /// Note that this only flattens nested tuples, not any other container type,
 /// e.g. a tuple<i32, tensor<i32>, tuple<f32, tuple<i64>>> is flattened to
 /// (i32, tensor<i32>, f32, i64)
 void TupleType::getFlattenedTypes(SmallVectorImpl<Type> &types) {
   for (Type type : getTypes()) {
-    if (auto nestedTuple = type.dyn_cast<TupleType>())
+    if (auto nestedTuple = llvm::dyn_cast<TupleType>(type))
       nestedTuple.getFlattenedTypes(types);
     else
       types.push_back(type);
   }
 }
 
 /// Return the number of element types.
 size_t TupleType::size() const { return getImpl()->size(); }

mlir/lib/IR/Diagnostics.cpp

for (auto &handlerIt : llvm::reverse(handlers))
     if (succeeded(handlerIt.second(diag)))
       return;
 
   // Otherwise, if this is an error we emit it to stderr.
   if (diag.getSeverity() != DiagnosticSeverity::Error)
     return;
 
   auto &os = llvm::errs();
-  if (!diag.getLocation().isa<UnknownLoc>())
+  if (!llvm::isa<UnknownLoc>(diag.getLocation()))
     os << diag.getLocation() << ": ";
   os << "error: ";
 
   // The default behavior for errors is to emit them to stderr.
   os << diag << '\n';
   os.flush();
 }
 
void SourceMgrDiagnosticHandler::emitDiagnostic(Location loc, Twine message,
                                                 bool displaySourceLine) {
   // Extract a file location from this loc.
   auto fileLoc = loc->findInstanceOf<FileLineColLoc>();
 
   // If one doesn't exist, then print the raw message without a source location.
   if (!fileLoc) {
     std::string str;
     llvm::raw_string_ostream strOS(str);
-    if (!loc.isa<UnknownLoc>())
+    if (!llvm::isa<UnknownLoc>(loc))
       strOS << loc << ": ";
     strOS << message;
     return mgr.PrintMessage(os, SMLoc(), getDiagKind(kind), strOS.str());
   }
 
   // Otherwise if we are displaying the source line, try to convert the file
   // location to an SMLoc.
   if (displaySourceLine) {
if (diagnostics.empty())
       return;
 
     os << "In-Flight Diagnostics:\n";
     emitDiagnostics([&](const Diagnostic &diag) {
       os.indent(4);
 
       // Print each diagnostic with the format:
       //   "<location>: <kind>: <msg>"
-      if (!diag.getLocation().isa<UnknownLoc>())
+      if (!llvm::isa<UnknownLoc>(diag.getLocation()))
         os << diag.getLocation() << ": ";
       switch (diag.getSeverity()) {
       case DiagnosticSeverity::Error:
         os << "error: ";
         break;
       case DiagnosticSeverity::Warning:
         os << "warning: ";
         break;

mlir/lib/IR/ExtensibleDialect.cpp

OptionalParseResult ExtensibleDialect::parseOptionalDynamicType(
   if (DynamicType::parse(parser, typeDef, dynType))
     return failure();
   resultType = dynType;
   return success();
 }
 
 LogicalResult ExtensibleDialect::printIfDynamicType(Type type,
                                                     AsmPrinter &printer) {
-  if (auto dynType = type.dyn_cast<DynamicType>()) {
+  if (auto dynType = llvm::dyn_cast<DynamicType>(type)) {
     dynType.print(printer);
     return success();
   }
   return failure();
 }
 
 OptionalParseResult ExtensibleDialect::parseOptionalDynamicAttr(
     StringRef attrName, AsmParser &parser, Attribute &resultAttr) const {
   DynamicAttrDefinition *attrDef = lookupAttrDefinition(attrName);
   if (!attrDef)
     return std::nullopt;
 
   DynamicAttr dynAttr;
   if (DynamicAttr::parse(parser, attrDef, dynAttr))
     return failure();
   resultAttr = dynAttr;
   return success();
 }
 
 LogicalResult ExtensibleDialect::printIfDynamicAttr(Attribute attribute,
                                                     AsmPrinter &printer) {
-  if (auto dynAttr = attribute.dyn_cast<DynamicAttr>()) {
+  if (auto dynAttr = llvm::dyn_cast<DynamicAttr>(attribute)) {
     dynAttr.print(printer);
     return success();
   }
   return failure();
 }
 
 //===----------------------------------------------------------------------===//
 // Dynamic dialect

mlir/lib/IR/FunctionImplementation.cpp

 /// contain a set of DictionaryAttrs of the same arity as `types`.
 static void printFunctionResultList(OpAsmPrinter &p, ArrayRef<Type> types,
                                     ArrayAttr attrs) {
   assert(!types.empty() && "Should not be called for empty result list.");
   assert((!attrs || attrs.size() == types.size()) &&
          "Invalid number of attributes.");
 
   auto &os = p.getStream();
-  bool needsParens = types.size() > 1 || types[0].isa<FunctionType>() ||
-                     (attrs && !attrs[0].cast<DictionaryAttr>().empty());
+  bool needsParens = types.size() > 1 || llvm::isa<FunctionType>(types[0]) ||
+                     (attrs && !llvm::cast<DictionaryAttr>(attrs[0]).empty());
   if (needsParens)
     os << '(';
   llvm::interleaveComma(llvm::seq<size_t>(0, types.size()), os, [&](size_t i) {
     p.printType(types[i]);
     if (attrs)
-      p.printOptionalAttrDict(attrs[i].cast<DictionaryAttr>().getValue());
+      p.printOptionalAttrDict(llvm::cast<DictionaryAttr>(attrs[i]).getValue());
   });
   if (needsParens)
     os << ')';
 }
 
 void function_interface_impl::printFunctionSignature(
     OpAsmPrinter &p, FunctionOpInterface op, ArrayRef<Type> argTypes,
     bool isVariadic, ArrayRef<Type> resultTypes) {
   Region &body = op->getRegion(0);
   bool isExternal = body.empty();
 
   p << '(';
   ArrayAttr argAttrs = op.getArgAttrsAttr();
   for (unsigned i = 0, e = argTypes.size(); i < e; ++i) {
     if (i > 0)
       p << ", ";
 
     if (!isExternal) {
       ArrayRef<NamedAttribute> attrs;
       if (argAttrs)
-        attrs = argAttrs[i].cast<DictionaryAttr>().getValue();
+        attrs = llvm::cast<DictionaryAttr>(argAttrs[i]).getValue();
       p.printRegionArgument(body.getArgument(i), attrs);
     } else {
       p.printType(argTypes[i]);
       if (argAttrs)
-        p.printOptionalAttrDict(argAttrs[i].cast<DictionaryAttr>().getValue());
+        p.printOptionalAttrDict(
+            llvm::cast<DictionaryAttr>(argAttrs[i]).getValue());
     }
   }
 
   if (isVariadic) {
     if (!argTypes.empty())
       p << ", ";
     p << "...";
   }

mlir/lib/IR/FunctionInterfaces.cpp

 
 #include "mlir/IR/FunctionOpInterfaces.cpp.inc"
 
 //===----------------------------------------------------------------------===//
 // Function Arguments and Results.
 //===----------------------------------------------------------------------===//
 
 static bool isEmptyAttrDict(Attribute attr) {
-  return attr.cast<DictionaryAttr>().empty();
+  return llvm::cast<DictionaryAttr>(attr).empty();
 }
 
 DictionaryAttr function_interface_impl::getArgAttrDict(FunctionOpInterface op,
                                                        unsigned index) {
   ArrayAttr attrs = op.getArgAttrsAttr();
   DictionaryAttr argAttrs =
-      attrs ? attrs[index].cast<DictionaryAttr>() : DictionaryAttr();
+      attrs ? llvm::cast<DictionaryAttr>(attrs[index]) : DictionaryAttr();
   return argAttrs;
 }
 
 DictionaryAttr
 function_interface_impl::getResultAttrDict(FunctionOpInterface op,
                                            unsigned index) {
   ArrayAttr attrs = op.getResAttrsAttr();
   DictionaryAttr resAttrs =
-      attrs ? attrs[index].cast<DictionaryAttr>() : DictionaryAttr();
+      attrs ? llvm::cast<DictionaryAttr>(attrs[index]) : DictionaryAttr();
   return resAttrs;
 }
 
 ArrayRef<NamedAttribute>
 function_interface_impl::getArgAttrs(FunctionOpInterface op, unsigned index) {
   auto argDict = getArgAttrDict(op, index);
   return argDict ? argDict.getValue() : std::nullopt;
 }
void function_interface_impl::eraseFunctionArguments(
   Block &entry = op->getRegion(0).front();
 
   // Update the argument attributes of the function.
   if (ArrayAttr argAttrs = op.getArgAttrsAttr()) {
     SmallVector<DictionaryAttr, 4> newArgAttrs;
     newArgAttrs.reserve(argAttrs.size());
     for (unsigned i = 0, e = argIndices.size(); i < e; ++i)
       if (!argIndices[i])
-        newArgAttrs.emplace_back(argAttrs[i].cast<DictionaryAttr>());
+        newArgAttrs.emplace_back(llvm::cast<DictionaryAttr>(argAttrs[i]));
     setAllArgAttrDicts(op, newArgAttrs);
   }
 
   // Update the function type and any entry block arguments.
   op.setFunctionTypeAttr(TypeAttr::get(newType));
   entry.eraseArguments(argIndices);
 }
 
 void function_interface_impl::eraseFunctionResults(
     FunctionOpInterface op, const BitVector &resultIndices, Type newType) {
   // There are 2 things that need to be updated:
   // - Function type.
   // - Result attrs.
 
   // Update the result attributes of the function.
   if (ArrayAttr resAttrs = op.getResAttrsAttr()) {
     SmallVector<DictionaryAttr, 4> newResultAttrs;
     newResultAttrs.reserve(resAttrs.size());
     for (unsigned i = 0, e = resultIndices.size(); i < e; ++i)
       if (!resultIndices[i])
-        newResultAttrs.emplace_back(resAttrs[i].cast<DictionaryAttr>());
+        newResultAttrs.emplace_back(llvm::cast<DictionaryAttr>(resAttrs[i]));
     setAllResultAttrDicts(op, newResultAttrs);
   }
 
   // Update the function type.
   op.setFunctionTypeAttr(TypeAttr::get(newType));
 }
 
 TypeRange function_interface_impl::insertTypesInto(

mlir/lib/IR/Location.cpp

return TypeSwitch<LocationAttr, WalkResult>(*this)
       .Case([&](OpaqueLoc opaqueLoc) -> WalkResult {
         return opaqueLoc.getFallbackLocation()->walk(walkFn);
       })
       .Default(WalkResult::advance());
 }
 
 /// Methods for support type inquiry through isa, cast, and dyn_cast.
 bool LocationAttr::classof(Attribute attr) {
-  return attr.isa<CallSiteLoc, FileLineColLoc, FusedLoc, NameLoc, OpaqueLoc,
-                  UnknownLoc>();
+  return llvm::isa<CallSiteLoc, FileLineColLoc, FusedLoc, NameLoc, OpaqueLoc,
+                   UnknownLoc>(attr);
 }
 
 //===----------------------------------------------------------------------===//
 // CallSiteLoc
 //===----------------------------------------------------------------------===//
 
 CallSiteLoc CallSiteLoc::get(Location name, ArrayRef<Location> frames) {
   assert(!frames.empty() && "required at least 1 call frame");
if (auto fusedLoc = llvm::dyn_cast<FusedLoc>(loc)) {
         // UnknownLoc's have already been removed from FusedLocs so we can
         // simply add all of the internal locations.
         decomposedLocs.insert(fusedLoc.getLocations().begin(),
                               fusedLoc.getLocations().end());
         continue;
       }
     }
     // Otherwise, only add known locations to the set.
-    if (!loc.isa<UnknownLoc>())
+    if (!llvm::isa<UnknownLoc>(loc))
       decomposedLocs.insert(loc);
   }
   locs = decomposedLocs.getArrayRef();
 
   // Handle the simple cases of less than two locations. Ensure the metadata (if
   // provided) is not dropped.
   if (locs.empty()) {
     if (!metadata)

mlir/lib/IR/Operation.cpp

return op->emitOpError()
            << "expected " << numOperands << " or more operands, but found "
            << op->getNumOperands();
   return success();
 }
 
 /// If this is a vector type, or a tensor type, return the scalar element type
 /// that it is built around, otherwise return the type unmodified.
 static Type getTensorOrVectorElementType(Type type) {
-  if (auto vec = type.dyn_cast<VectorType>())
+  if (auto vec = llvm::dyn_cast<VectorType>(type))
     return vec.getElementType();
 
   // Look through tensor<vector<...>> to find the underlying element type.
-  if (auto tensor = type.dyn_cast<TensorType>())
+  if (auto tensor = llvm::dyn_cast<TensorType>(type))
     return getTensorOrVectorElementType(tensor.getElementType());
   return type;
 }
 
 LogicalResult OpTrait::impl::verifyIsIdempotent(Operation *op) {
   // FIXME: Add back check for no side effects on operation.
   // Currently adding it would cause the shared library build
   // to fail since there would be a dependency of IR on SideEffectInterfaces
if (!type.isSignlessIntOrIndex())
       return op->emitOpError() << "requires an integer or index type";
   }
   return success();
 }
 
 LogicalResult OpTrait::impl::verifyOperandsAreFloatLike(Operation *op) {
   for (auto opType : op->getOperandTypes()) {
     auto type = getTensorOrVectorElementType(opType);
-    if (!type.isa<FloatType>())
+    if (!llvm::isa<FloatType>(type))
       return op->emitOpError("requires a float type");
   }
   return success();
 }
 
 LogicalResult OpTrait::impl::verifySameTypeOperands(Operation *op) {
   // Zero or one operand always have the "same" type.
   unsigned nOperands = op->getNumOperands();
if (!isBoolType)
       return op->emitOpError() << "requires a bool result type";
   }
 
   return success();
 }
 
 LogicalResult OpTrait::impl::verifyResultsAreFloatLike(Operation *op) {
   for (auto resultType : op->getResultTypes())
-    if (!getTensorOrVectorElementType(resultType).isa<FloatType>())
+    if (!llvm::isa<FloatType>(getTensorOrVectorElementType(resultType)))
       return op->emitOpError() << "requires a floating point type";
 
   return success();
 }
 
 LogicalResult
 OpTrait::impl::verifyResultsAreSignlessIntegerLike(Operation *op) {
   for (auto resultType : op->getResultTypes())
if (region.getNumArguments() != 0) {
       return op->emitOpError("region should have no arguments");
     }
   }
   return success();
 }
 
 LogicalResult OpTrait::impl::verifyElementwise(Operation *op) {
   auto isMappableType = [](Type type) {
-    return type.isa<VectorType, TensorType>();
+    return llvm::isa<VectorType, TensorType>(type);
   };
   auto resultMappableTypes = llvm::to_vector<1>(
       llvm::make_filter_range(op->getResultTypes(), isMappableType));
   auto operandMappableTypes = llvm::to_vector<2>(
       llvm::make_filter_range(op->getOperandTypes(), isMappableType));
 
   // If the op only has scalar operand/result types, then we have nothing to
   // check.

mlir/lib/IR/OperationSupport.cpp

 
 DictionaryAttr NamedAttrList::getDictionary(MLIRContext *context) const {
   if (!isSorted()) {
     DictionaryAttr::sortInPlace(attrs);
     dictionarySorted.setPointerAndInt(nullptr, true);
   }
   if (!dictionarySorted.getPointer())
     dictionarySorted.setPointer(DictionaryAttr::getWithSorted(context, attrs));
-  return dictionarySorted.getPointer().cast<DictionaryAttr>();
+  return llvm::cast<DictionaryAttr>(dictionarySorted.getPointer());
 }
 
 /// Add an attribute with the specified name.
 void NamedAttrList::append(StringRef name, Attribute attr) {
   append(StringAttr::get(attr.getContext(), name), attr);
 }
 
 /// Replaces the attributes with new list of attributes.

 }
 
 //===----------------------------------------------------------------------===//
 // OperandRangeRange
 
 OperandRangeRange::OperandRangeRange(OperandRange operands,
                                      Attribute operandSegments)
     : OperandRangeRange(OwnerT(operands.getBase(), operandSegments), 0,
-                        operandSegments.cast<DenseI32ArrayAttr>().size()) {}
+                        llvm::cast<DenseI32ArrayAttr>(operandSegments).size()) {
+}
 
 OperandRange OperandRangeRange::join() const {
   const OwnerT &owner = getBase();
-  ArrayRef<int32_t> sizeData = owner.second.cast<DenseI32ArrayAttr>();
+  ArrayRef<int32_t> sizeData = llvm::cast<DenseI32ArrayAttr>(owner.second);
   return OperandRange(owner.first,
                       std::accumulate(sizeData.begin(), sizeData.end(), 0));
 }
 
 OperandRange OperandRangeRange::dereference(const OwnerT &object,
                                             ptrdiff_t index) {
-  ArrayRef<int32_t> sizeData = object.second.cast<DenseI32ArrayAttr>();
+  ArrayRef<int32_t> sizeData = llvm::cast<DenseI32ArrayAttr>(object.second);
   uint32_t startIndex =
       std::accumulate(sizeData.begin(), sizeData.begin() + index, 0);
   return OperandRange(object.first + startIndex, *(sizeData.begin() + index));
 }
 
 //===----------------------------------------------------------------------===//
 // MutableOperandRange
 

 
 /// Update the length of this range to the one provided.
 void MutableOperandRange::updateLength(unsigned newLength) {
   int32_t diff = int32_t(newLength) - int32_t(length);
   length = newLength;
 
   // Update any of the provided segment attributes.
   for (OperandSegment &segment : operandSegments) {
-    auto attr = segment.second.getValue().cast<DenseI32ArrayAttr>();
+    auto attr = llvm::cast<DenseI32ArrayAttr>(segment.second.getValue());
     SmallVector<int32_t, 8> segments(attr.asArrayRef());
     segments[segment.first] += diff;
     segment.second.setValue(
         DenseI32ArrayAttr::get(attr.getContext(), segments));
     owner->setAttr(segment.second.getName(), segment.second.getValue());
   }
 }
 
 //===----------------------------------------------------------------------===//
 // MutableOperandRangeRange
 
 MutableOperandRangeRange::MutableOperandRangeRange(
     const MutableOperandRange &operands, NamedAttribute operandSegmentAttr)
     : MutableOperandRangeRange(
           OwnerT(operands, operandSegmentAttr), 0,
-          operandSegmentAttr.getValue().cast<DenseI32ArrayAttr>().size()) {}
+          llvm::cast<DenseI32ArrayAttr>(operandSegmentAttr.getValue()).size()) {
+}
 
 MutableOperandRange MutableOperandRangeRange::join() const {
   return getBase().first;
 }
 
 MutableOperandRangeRange::operator OperandRangeRange() const {
   return OperandRangeRange(getBase().first, getBase().second.getValue());
 }
 
 MutableOperandRange MutableOperandRangeRange::dereference(const OwnerT &object,
                                                           ptrdiff_t index) {
   ArrayRef<int32_t> sizeData =
-      object.second.getValue().cast<DenseI32ArrayAttr>();
+      llvm::cast<DenseI32ArrayAttr>(object.second.getValue());
   uint32_t startIndex =
       std::accumulate(sizeData.begin(), sizeData.begin() + index, 0);
   return object.first.slice(
       startIndex, *(sizeData.begin() + index),
       MutableOperandRange::OperandSegment(index, object.second));
 }
 
 //===----------------------------------------------------------------------===//
/*static*/ bool OperationEquivalence::isEquivalentTo(
 
   // 2. Compare operands.
   ValueRange lhsOperands = lhs->getOperands(), rhsOperands = rhs->getOperands();
   SmallVector<Value> lhsOperandStorage, rhsOperandStorage;
   if (lhs->hasTrait<mlir::OpTrait::IsCommutative>()) {
     auto sortValues = [](ValueRange values) {
       SmallVector<Value> sortedValues = llvm::to_vector(values);
       llvm::sort(sortedValues, [](Value a, Value b) {
-        auto aArg = a.dyn_cast<BlockArgument>();
-        auto bArg = b.dyn_cast<BlockArgument>();
+        auto aArg = llvm::dyn_cast<BlockArgument>(a);
+        auto bArg = llvm::dyn_cast<BlockArgument>(b);
 
         // Case 1. Both `a` and `b` are `BlockArgument`s.
         if (aArg && bArg) {
           if (aArg.getParentBlock() == bArg.getParentBlock())
             return aArg.getArgNumber() < bArg.getArgNumber();
           return aArg.getParentBlock() < bArg.getParentBlock();
         }
 

mlir/lib/IR/SymbolTable.cpp

 LogicalResult detail::verifySymbol(Operation *op) {
   // Verify the name attribute.
   if (!op->getAttrOfType<StringAttr>(mlir::SymbolTable::getSymbolAttrName()))
     return op->emitOpError() << "requires string attribute '"
                              << mlir::SymbolTable::getSymbolAttrName() << "'";
 
   // Verify the visibility attribute.
   if (Attribute vis = op->getAttr(mlir::SymbolTable::getVisibilityAttrName())) {
-    StringAttr visStrAttr = vis.dyn_cast<StringAttr>();
+    StringAttr visStrAttr = llvm::dyn_cast<StringAttr>(vis);
     if (!visStrAttr)
       return op->emitOpError() << "requires visibility attribute '"
                                << mlir::SymbolTable::getVisibilityAttrName()
                                << "' to be a string attribute, but got " << vis;
 
     if (!llvm::is_contained(ArrayRef<StringRef>{"public", "private", "nested"},
                             visStrAttr.getValue()))
       return op->emitOpError()

 /// Returns true if the given reference 'SubRef' is a sub reference of the
 /// reference 'ref', i.e. 'ref' is a further qualified reference.
 static bool isReferencePrefixOf(SymbolRefAttr subRef, SymbolRefAttr ref) {
   if (ref == subRef)
     return true;
 
   // If the references are not pointer equal, check to see if `subRef` is a
   // prefix of `ref`.
-  if (ref.isa<FlatSymbolRefAttr>() ||
+  if (llvm::isa<FlatSymbolRefAttr>(ref) ||
       ref.getRootReference() != subRef.getRootReference())
     return false;
 
   auto refLeafs = ref.getNestedReferences();
   auto subRefLeafs = subRef.getNestedReferences();
   return subRefLeafs.size() < refLeafs.size() &&
          subRefLeafs == refLeafs.take_front(subRefLeafs.size());
 }

 }
 
 //===----------------------------------------------------------------------===//
 // SymbolTable::replaceAllSymbolUses
 
 /// Generates a new symbol reference attribute with a new leaf reference.
 static SymbolRefAttr generateNewRefAttr(SymbolRefAttr oldAttr,
                                         FlatSymbolRefAttr newLeafAttr) {
-  if (oldAttr.isa<FlatSymbolRefAttr>())
+  if (llvm::isa<FlatSymbolRefAttr>(oldAttr))
     return newLeafAttr;
   auto nestedRefs = llvm::to_vector<2>(oldAttr.getNestedReferences());
   nestedRefs.back() = newLeafAttr;
   return SymbolRefAttr::get(oldAttr.getRootReference(), nestedRefs);
 }
 
 /// The implementation of SymbolTable::replaceAllSymbolUses below.
 template <typename SymbolT, typename IRUnitT>

mlir/lib/IR/TypeUtilities.cpp

 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Types.h"
 #include "mlir/IR/Value.h"
 
 using namespace mlir;
 
 Type mlir::getElementTypeOrSelf(Type type) {
-  if (auto st = type.dyn_cast<ShapedType>())
+  if (auto st = llvm::dyn_cast<ShapedType>(type))
     return st.getElementType();
   return type;
 }
 
 Type mlir::getElementTypeOrSelf(Value val) {
   return getElementTypeOrSelf(val.getType());
 }
 
 Type mlir::getElementTypeOrSelf(Attribute attr) {
-  if (auto typedAttr = attr.dyn_cast<TypedAttr>())
+  if (auto typedAttr = llvm::dyn_cast<TypedAttr>(attr))
     return getElementTypeOrSelf(typedAttr.getType());
   return {};
 }
 
 SmallVector<Type, 10> mlir::getFlattenedTypes(TupleType t) {
   SmallVector<Type, 10> fTypes;
   t.getFlattenedTypes(fTypes);
   return fTypes;
 }
 
 /// Return true if the specified type is an opaque type with the specified
 /// dialect and typeData.
 bool mlir::isOpaqueTypeWithName(Type type, StringRef dialect,
                                 StringRef typeData) {
-  if (auto opaque = type.dyn_cast<mlir::OpaqueType>())
+  if (auto opaque = llvm::dyn_cast<mlir::OpaqueType>(type))
     return opaque.getDialectNamespace() == dialect &&
            opaque.getTypeData() == typeData;
   return false;
 }
 
 /// Returns success if the given two shapes are compatible. That is, they have
 /// the same size and each pair of the elements are equal or one of them is
 /// dynamic.

 }
 
 /// Returns success if the given two types have compatible shape. That is,
 /// they are both scalars (not shaped), or they are both shaped types and at
 /// least one is unranked or they have compatible dimensions. Dimensions are
 /// compatible if at least one is dynamic or both are equal. The element type
 /// does not matter.
 LogicalResult mlir::verifyCompatibleShape(Type type1, Type type2) {
-  auto sType1 = type1.dyn_cast<ShapedType>();
-  auto sType2 = type2.dyn_cast<ShapedType>();
+  auto sType1 = llvm::dyn_cast<ShapedType>(type1);
+  auto sType2 = llvm::dyn_cast<ShapedType>(type2);
 
   // Either both or neither type should be shaped.
   if (!sType1)
     return success(!sType2);
   if (!sType2)
     return failure();
 
   if (!sType1.hasRank() || !sType2.hasRank())

 }
 
 /// Returns success if all given types have compatible shapes. That is, they are
 /// all scalars (not shaped), or they are all shaped types and any ranked shapes
 /// have compatible dimensions. Dimensions are compatible if all non-dynamic
 /// dims are equal. The element type does not matter.
 LogicalResult mlir::verifyCompatibleShapes(TypeRange types) {
   auto shapedTypes = llvm::to_vector<8>(llvm::map_range(
-      types, [](auto type) { return type.template dyn_cast<ShapedType>(); }));
+      types, [](auto type) { return llvm::dyn_cast<ShapedType>(type); }));
   // Return failure if some, but not all are not shaped. Return early if none
   // are shaped also.
   if (llvm::none_of(shapedTypes, [](auto t) { return t; }))
     return success();
   if (!llvm::all_of(shapedTypes, [](auto t) { return t; }))
     return failure();
 
   // Return failure if some, but not all, are scalable vectors.
   bool hasScalableVecTypes = false;
   bool hasNonScalableVecTypes = false;
   for (Type t : types) {
-    auto vType = t.dyn_cast<VectorType>();
+    auto vType = llvm::dyn_cast<VectorType>(t);
     if (vType && vType.isScalable())
       hasScalableVecTypes = true;
     else
       hasNonScalableVecTypes = true;
     if (hasScalableVecTypes && hasNonScalableVecTypes)
       return failure();
   }
 
for (unsigned i = 0; i < firstRank; ++i) {
     if (verifyCompatibleDims(dims).failed())
       return failure();
   }
 
   return success();
 }
 
 Type OperandElementTypeIterator::mapElement(Value value) const {
-  return value.getType().cast<ShapedType>().getElementType();
+  return llvm::cast<ShapedType>(value.getType()).getElementType();
 }
 
 Type ResultElementTypeIterator::mapElement(Value value) const {
-  return value.getType().cast<ShapedType>().getElementType();
+  return llvm::cast<ShapedType>(value.getType()).getElementType();
 }

mlir/lib/IR/Verifier.cpp

if (auto *useOp = operand.getDefiningOp()) {
     else if (region1->isProperAncestor(region2))
       note << " (op in a child region)";
     else
       note << " (op is neither in a parent nor in a child region)";
     return;
   }
   // Block argument case.
   Block *block1 = op.getBlock();
-  Block *block2 = operand.cast<BlockArgument>().getOwner();
+  Block *block2 = llvm::cast<BlockArgument>(operand).getOwner();
   Region *region1 = block1->getParent();
   Region *region2 = block2->getParent();
   Location loc = UnknownLoc::get(op.getContext());
   if (block2->getParentOp())
     loc = block2->getParentOp()->getLoc();
   Diagnostic &note = diag.attachNote(loc);
   if (!region2) {
     note << " (block without parent)";

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

while (succeeded(*parser.parseOptionalInteger(intVal))) {
     elements.push_back(intVal);
     if (parser.parseOptionalComma())
       break;
   }
 
   if (parser.parseRSquare() || parser.parseGreater())
     return Attribute();
   return parser.getChecked<TestI64ElementsAttr>(
-      parser.getContext(), type.cast<ShapedType>(), elements);
+      parser.getContext(), llvm::cast<ShapedType>(type), elements);
 }
 
 void TestI64ElementsAttr::print(AsmPrinter &printer) const {
   printer << "<[";
   llvm::interleaveComma(getElements(), printer);
   printer << "] : " << getType() << ">";
 }
 

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

 }
 
 LogicalResult
 TestTypeWithLayoutType::verifyEntries(DataLayoutEntryListRef params,
                                       Location loc) const {
   for (DataLayoutEntryInterface entry : params) {
     // This is for testing purposes only, so assert well-formedness.
     assert(entry.isTypeEntry() && "unexpected identifier entry");
-    assert(entry.getKey().get<Type>().isa<TestTypeWithLayoutType>() &&
+    assert(llvm::isa<TestTypeWithLayoutType>(entry.getKey().get<Type>()) &&
            "wrong type passed in");
-    auto array = entry.getValue().dyn_cast<ArrayAttr>();
+    auto array = llvm::dyn_cast<ArrayAttr>(entry.getValue());
     assert(array && array.getValue().size() == 2 &&
            "expected array of two elements");
-    auto kind = array.getValue().front().dyn_cast<StringAttr>();
+    auto kind = llvm::dyn_cast<StringAttr>(array.getValue().front());
     (void)kind;
     assert(kind &&
            (kind.getValue() == "size" || kind.getValue() == "alignment" ||
             kind.getValue() == "preferred") &&
            "unexpected kind");
-    assert(array.getValue().back().isa<IntegerAttr>());
+    assert(llvm::isa<IntegerAttr>(array.getValue().back()));
   }
   return success();
 }
 
 unsigned TestTypeWithLayoutType::extractKind(DataLayoutEntryListRef params,
                                              StringRef expectedKind) const {
   for (DataLayoutEntryInterface entry : params) {
-    ArrayRef<Attribute> pair = entry.getValue().cast<ArrayAttr>().getValue();
-    StringRef kind = pair.front().cast<StringAttr>().getValue();
+    ArrayRef<Attribute> pair =
+        llvm::cast<ArrayAttr>(entry.getValue()).getValue();
+    StringRef kind = llvm::cast<StringAttr>(pair.front()).getValue();
     if (kind == expectedKind)
-      return pair.back().cast<IntegerAttr>().getValue().getZExtValue();
+      return llvm::cast<IntegerAttr>(pair.back()).getValue().getZExtValue();
   }
   return 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Dynamic Types
 //===----------------------------------------------------------------------===//
 

 void TestDialect::printTestType(Type type, AsmPrinter &printer,
                                 SetVector<Type> &stack) const {
   if (succeeded(generatedTypePrinter(type, printer)))
     return;
 
   if (succeeded(printIfDynamicType(type, printer)))
     return;
 
-  auto rec = type.cast<TestRecursiveType>();
+  auto rec = llvm::cast<TestRecursiveType>(type);
   printer << "test_rec<" << rec.getName();
   if (!stack.contains(rec)) {
     printer << ", ";
     stack.insert(rec);
     printTestType(rec.getBody(), printer, stack);
     stack.pop_back();
   }
   printer << ">";
 }
 
 void TestDialect::printType(Type type, DialectAsmPrinter &printer) const {
   SetVector<Type> stack;
   printTestType(type, printer, stack);
 }

mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.cpp

public:
   void getEffects(SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {}
 };
 } // namespace
 
 DiagnosedSilenceableFailure
 mlir::test::TestProduceSelfHandleOrForwardOperandOp::apply(
     transform::TransformResults &results, transform::TransformState &state) {
   if (getOperation()->getNumOperands() != 0) {
-    results.set(getResult().cast<OpResult>(),
+    results.set(llvm::cast<OpResult>(getResult()),
                 getOperation()->getOperand(0).getDefiningOp());
   } else {
-    results.set(getResult().cast<OpResult>(), getOperation());
+    results.set(llvm::cast<OpResult>(getResult()), getOperation());
   }
   return DiagnosedSilenceableFailure::success();
 }
 
 void mlir::test::TestProduceSelfHandleOrForwardOperandOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   if (getOperand())
     transform::onlyReadsHandle(getOperand(), effects);
   transform::producesHandle(getRes(), effects);
 }
 
 DiagnosedSilenceableFailure
 mlir::test::TestProduceValueHandleToSelfOperand::apply(
     transform::TransformResults &results, transform::TransformState &state) {
-  results.setValues(getOut().cast<OpResult>(), getIn());
+  results.setValues(llvm::cast<OpResult>(getOut()), getIn());
   return DiagnosedSilenceableFailure::success();
 }
 
 void mlir::test::TestProduceValueHandleToSelfOperand::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   transform::onlyReadsHandle(getIn(), effects);
   transform::producesHandle(getOut(), effects);
   transform::onlyReadsPayload(effects);

 }
 
 DiagnosedSilenceableFailure mlir::test::TestPrintRemarkAtOperandValue::apply(
     transform::TransformResults &results, transform::TransformState &state) {
   ArrayRef<Value> values = state.getPayloadValues(getIn());
   for (Value value : values) {
     std::string note;
     llvm::raw_string_ostream os(note);
-    if (auto arg = value.dyn_cast<BlockArgument>()) {
+    if (auto arg = llvm::dyn_cast<BlockArgument>(value)) {
       os << "a block argument #" << arg.getArgNumber() << " in block #"
          << std::distance(arg.getOwner()->getParent()->begin(),
                           arg.getOwner()->getIterator())
          << " in region #" << arg.getOwner()->getParent()->getRegionNumber();
     } else {
-      os << "an op result #" << value.cast<OpResult>().getResultNumber();
+      os << "an op result #" << llvm::cast<OpResult>(value).getResultNumber();
     }
     InFlightDiagnostic diag = ::emitRemark(value.getLoc()) << getMessage();
     diag.attachNote() << "value handle points to " << os.str();
   }
   return DiagnosedSilenceableFailure::success();
 }
 
 void mlir::test::TestPrintRemarkAtOperandValue::getEffects(
DiagnosedSilenceableFailure mlir::test::TestRemapOperandPayloadToSelfOp::apply(
   auto *extension = state.getExtension<TestTransformStateExtension>();
   if (!extension)
     return emitDefiniteFailure("TestTransformStateExtension missing");
 
   if (failed(extension->updateMapping(state.getPayloadOps(getOperand()).front(),
                                       getOperation())))
     return DiagnosedSilenceableFailure::definiteFailure();
   if (getNumResults() > 0)
-    results.set(getResult(0).cast<OpResult>(), getOperation());
+    results.set(llvm::cast<OpResult>(getResult(0)), getOperation());
   return DiagnosedSilenceableFailure::success();
 }
 
 void mlir::test::TestRemapOperandPayloadToSelfOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   transform::onlyReadsHandle(getOperand(), effects);
   transform::producesHandle(getOut(), effects);
   transform::onlyReadsPayload(effects);
 }
 
 DiagnosedSilenceableFailure mlir::test::TestRemoveTestExtensionOp::apply(
     transform::TransformResults &results, transform::TransformState &state) {
   state.removeExtension<TestTransformStateExtension>();
   return DiagnosedSilenceableFailure::success();
 }
 
 DiagnosedSilenceableFailure
 mlir::test::TestReversePayloadOpsOp::apply(transform::TransformResults &results,
                                            transform::TransformState &state) {
   ArrayRef<Operation *> payloadOps = state.getPayloadOps(getTarget());
   auto reversedOps = llvm::to_vector(llvm::reverse(payloadOps));
-  results.set(getResult().cast<OpResult>(), reversedOps);
+  results.set(llvm::cast<OpResult>(getResult()), reversedOps);
   return DiagnosedSilenceableFailure::success();
 }
 
 DiagnosedSilenceableFailure mlir::test::TestTransformOpWithRegions::apply(
     transform::TransformResults &results, transform::TransformState &state) {
   return DiagnosedSilenceableFailure::success();
 }
 

 void mlir::test::TestPrintNumberOfAssociatedPayloadIROps::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   transform::onlyReadsHandle(getHandle(), effects);
 }
 
 DiagnosedSilenceableFailure
 mlir::test::TestCopyPayloadOp::apply(transform::TransformResults &results,
                                      transform::TransformState &state) {
-  results.set(getCopy().cast<OpResult>(), state.getPayloadOps(getHandle()));
+  results.set(llvm::cast<OpResult>(getCopy()),
+              state.getPayloadOps(getHandle()));
   return DiagnosedSilenceableFailure::success();
 }
 
 void mlir::test::TestCopyPayloadOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   transform::onlyReadsHandle(getHandle(), effects);
   transform::producesHandle(getCopy(), effects);
   transform::onlyReadsPayload(effects);
DiagnosedSilenceableFailure mlir::transform::TestDialectOpType::checkPayload(
   }
 
   return DiagnosedSilenceableFailure::success();
 }
 
 DiagnosedSilenceableFailure mlir::transform::TestDialectParamType::checkPayload(
     Location loc, ArrayRef<Attribute> payload) const {
   for (Attribute attr : payload) {
-    auto integerAttr = attr.dyn_cast<IntegerAttr>();
+    auto integerAttr = llvm::dyn_cast<IntegerAttr>(attr);
     if (integerAttr && integerAttr.getType().isSignlessInteger(32))
       continue;
     return emitSilenceableError(loc)
            << "expected the parameter to be a i32 integer attribute";
   }
 
   return DiagnosedSilenceableFailure::success();
 }

 
 DiagnosedSilenceableFailure
 mlir::test::TestAddToParamOp::apply(transform::TransformResults &results,
                                     transform::TransformState &state) {
   SmallVector<uint32_t> values(/*Size=*/1, /*Value=*/0);
   if (Value param = getParam()) {
     values = llvm::to_vector(
         llvm::map_range(state.getParams(param), [](Attribute attr) -> uint32_t {
-          return attr.cast<IntegerAttr>().getValue().getLimitedValue(
+          return llvm::cast<IntegerAttr>(attr).getValue().getLimitedValue(
               UINT32_MAX);
         }));
   }
 
   Builder builder(getContext());
   SmallVector<Attribute> result = llvm::to_vector(
       llvm::map_range(values, [this, &builder](uint32_t value) -> Attribute {
         return builder.getI32IntegerAttr(value + getAddendum());
       }));
-  results.setParams(getResult().cast<OpResult>(), result);
+  results.setParams(llvm::cast<OpResult>(getResult()), result);
   return DiagnosedSilenceableFailure::success();
 }
 
 DiagnosedSilenceableFailure
 mlir::test::TestProduceParamWithNumberOfTestOps::apply(
     transform::TransformResults &results, transform::TransformState &state) {
   Builder builder(getContext());
   SmallVector<Attribute> result = llvm::to_vector(
       llvm::map_range(state.getPayloadOps(getHandle()),
                       [&builder](Operation *payload) -> Attribute {
                         int32_t count = 0;
                         payload->walk([&count](Operation *op) {
                           if (op->getName().getDialectNamespace() == "test")
                             ++count;
                         });
                         return builder.getI32IntegerAttr(count);
                       }));
-  results.setParams(getResult().cast<OpResult>(), result);
+  results.setParams(llvm::cast<OpResult>(getResult()), result);
   return DiagnosedSilenceableFailure::success();
 }
 
 DiagnosedSilenceableFailure
 mlir::test::TestProduceIntegerParamWithTypeOp::apply(
     transform::TransformResults &results, transform::TransformState &state) {
   Attribute zero = IntegerAttr::get(getType(), 0);
-  results.setParams(getResult().cast<OpResult>(), zero);
+  results.setParams(llvm::cast<OpResult>(getResult()), zero);
   return DiagnosedSilenceableFailure::success();
 }
 
 LogicalResult mlir::test::TestProduceIntegerParamWithTypeOp::verify() {
-  if (!getType().isa<IntegerType>()) {
+  if (!llvm::isa<IntegerType>(getType())) {
     return emitOpError() << "expects an integer type";
   }
   return success();
 }
 
 void mlir::test::TestProduceTransformParamOrForwardOperandOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   transform::onlyReadsHandle(getIn(), effects);

 void mlir::test::TestProduceNullPayloadOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   transform::producesHandle(getOut(), effects);
 }
 
 DiagnosedSilenceableFailure mlir::test::TestProduceNullPayloadOp::apply(
     transform::TransformResults &results, transform::TransformState &state) {
   SmallVector<Operation *, 1> null({nullptr});
-  results.set(getOut().cast<OpResult>(), null);
+  results.set(llvm::cast<OpResult>(getOut()), null);
   return DiagnosedSilenceableFailure::success();
 }
 
 void mlir::test::TestProduceNullParamOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   transform::producesHandle(getOut(), effects);
 }
 
 DiagnosedSilenceableFailure
 mlir::test::TestProduceNullParamOp::apply(transform::TransformResults &results,
                                           transform::TransformState &state) {
-  results.setParams(getOut().cast<OpResult>(), Attribute());
+  results.setParams(llvm::cast<OpResult>(getOut()), Attribute());
   return DiagnosedSilenceableFailure::success();
 }
 
 void mlir::test::TestProduceNullValueOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   transform::producesHandle(getOut(), effects);
 }
 
 DiagnosedSilenceableFailure
 mlir::test::TestProduceNullValueOp::apply(transform::TransformResults &results,
                                           transform::TransformState &state) {
-  results.setValues(getOut().cast<OpResult>(), Value());
+  results.setValues(llvm::cast<OpResult>(getOut()), Value());
   return DiagnosedSilenceableFailure::success();
 }
 
 void mlir::test::TestRequiredMemoryEffectsOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   if (getHasOperandEffect())
     transform::consumesHandle(getIn(), effects);
 
   if (getHasResultEffect())
     transform::producesHandle(getOut(), effects);
   else
     transform::onlyReadsHandle(getOut(), effects);
 
   if (getModifiesPayload())
     transform::modifiesPayload(effects);
 }
 
 DiagnosedSilenceableFailure mlir::test::TestRequiredMemoryEffectsOp::apply(
     transform::TransformResults &results, transform::TransformState &state) {
-  results.set(getOut().cast<OpResult>(), state.getPayloadOps(getIn()));
+  results.set(llvm::cast<OpResult>(getOut()), state.getPayloadOps(getIn()));
   return DiagnosedSilenceableFailure::success();
 }
 
 namespace {
 /// Test extension of the Transform dialect. Registers additional ops and
 /// declares PDL as dependent dialect since the additional ops are using PDL
 /// types for operands and results.
 class TestTransformDialectExtension

mlir/test/python/lib/PythonTestCAPI.cpp

 #include "mlir-c/BuiltinTypes.h"
 #include "mlir/CAPI/Registration.h"
 #include "mlir/CAPI/Wrap.h"
 
 MLIR_DEFINE_CAPI_DIALECT_REGISTRATION(PythonTest, python_test,
                                       python_test::PythonTestDialect)
 
 bool mlirAttributeIsAPythonTestTestAttribute(MlirAttribute attr) {
-  return unwrap(attr).isa<python_test::TestAttrAttr>();
+  return llvm::isa<python_test::TestAttrAttr>(unwrap(attr));
 }
 
 MlirAttribute mlirPythonTestTestAttributeGet(MlirContext context) {
   return wrap(python_test::TestAttrAttr::get(unwrap(context)));
 }
 
 bool mlirTypeIsAPythonTestTestType(MlirType type) {
-  return unwrap(type).isa<python_test::TestTypeType>();
+  return llvm::isa<python_test::TestTypeType>(unwrap(type));
 }
 
 MlirType mlirPythonTestTestTypeGet(MlirContext context) {
   return wrap(python_test::TestTypeType::get(unwrap(context)));
 }
 
 bool mlirTypeIsAPythonTestTestTensorValue(MlirValue value) {
   return mlirTypeIsATensor(wrap(unwrap(value).getType()));
 }

mlir/unittests/TableGen/EnumsGenTest.cpp

TEST(EnumsGenTest, GeneratedIntAttributeClass) {
   I32Enum rawVal = I32Enum::Case5;
 
   I32EnumAttr enumAttr = I32EnumAttr::get(&ctx, rawVal);
   EXPECT_NE(enumAttr, nullptr);
   EXPECT_EQ(enumAttr.getValue(), rawVal);
 
   mlir::Type intType = mlir::IntegerType::get(&ctx, 32);
   mlir::Attribute intAttr = mlir::IntegerAttr::get(intType, 5);
-  EXPECT_TRUE(intAttr.isa<I32EnumAttr>());
+  EXPECT_TRUE(llvm::isa<I32EnumAttr>(intAttr));
   EXPECT_EQ(intAttr, enumAttr);
 }
 
 TEST(EnumsGenTest, GeneratedBitAttributeClass) {
   mlir::MLIRContext ctx;
 
   mlir::Type intType = mlir::IntegerType::get(&ctx, 32);
   mlir::Attribute intAttr = mlir::IntegerAttr::get(
       intType,
       static_cast<uint32_t>(BitEnumWithNone::Bit0 | BitEnumWithNone::Bit3));
-  EXPECT_TRUE(intAttr.isa<BitEnumWithNoneAttr>());
-  EXPECT_TRUE(intAttr.isa<BitEnumWithoutNoneAttr>());
+  EXPECT_TRUE(llvm::isa<BitEnumWithNoneAttr>(intAttr));
+  EXPECT_TRUE(llvm::isa<BitEnumWithoutNoneAttr>(intAttr));
 
   intAttr = mlir::IntegerAttr::get(
       intType, static_cast<uint32_t>(BitEnumWithGroup::Bits0To3) | (1u << 6));
-  EXPECT_FALSE(intAttr.isa<BitEnumWithGroupAttr>());
+  EXPECT_FALSE(llvm::isa<BitEnumWithGroupAttr>(intAttr));
 }