Index: mlir/include/mlir/IR/Value.h
===================================================================
--- mlir/include/mlir/IR/Value.h
+++ mlir/include/mlir/IR/Value.h
@@ -88,26 +88,22 @@
 
   template <typename U>
   bool isa() const {
-    assert(*this && "isa<> used on a null type.");
-    return U::classof(*this);
+    return llvm::isa<U>(*this);
   }
 
-  template <typename First, typename Second, typename... Rest>
-  bool isa() const {
-    return isa<First>() || isa<Second, Rest...>();
-  }
   template <typename U>
   U dyn_cast() const {
-    return isa<U>() ? U(impl) : U(nullptr);
+    return llvm::dyn_cast<U>(*this);
   }
+
   template <typename U>
   U dyn_cast_or_null() const {
-    return (*this && isa<U>()) ? U(impl) : U(nullptr);
+    return llvm::dyn_cast_if_present<U>(*this);
   }
+
   template <typename U>
   U cast() const {
-    assert(isa<U>());
-    return U(impl);
+    return llvm::cast<U>(*this);
   }
 
   explicit operator bool() const { return impl; }
@@ -560,6 +556,31 @@
   }
 };
 
+/// Add support for llvm style casts. We provide a cast between To and From if
+/// From is mlir::Value or derives from it.
+template <typename To, typename From>
+struct CastInfo<
+    To, From,
+    std::enable_if_t<std::is_same_v<mlir::Value, std::remove_const_t<From>> ||
+                     std::is_base_of_v<mlir::Value, From>>>
+    : NullableValueCastFailed<To>,
+      DefaultDoCastIfPossible<To, From, CastInfo<To, From>> {
+  /// Arguments are taken as mlir::Value here and not as `From`, because
+  /// when casting from an intermediate type of the hierarchy to one of its
+  /// children, the val.getKind() inside T::classof will use the static
+  /// getKind() of the parent instead of the non-static ValueImpl::getKind()
+  /// that returns the dynamic type. This means that T::classof would end up
+  /// comparing the static Kind of the children to the static Kind of its
+  /// parent, making it impossible to downcast from the parent to the child.
+  static inline bool isPossible(mlir::Value ty) {
+    /// Return a constant true instead of a dynamic true when casting to self or
+    /// up the hierarchy.
+    return std::is_same_v<To, std::remove_const_t<From>> ||
+           std::is_base_of_v<To, From> || To::classof(ty);
+  }
+  static inline To doCast(mlir::Value value) { return To(value.getImpl()); }
+};
+
 } // namespace llvm
 
 #endif
Index: mlir/lib/AsmParser/AsmParserState.cpp
===================================================================
--- mlir/lib/AsmParser/AsmParserState.cpp
+++ mlir/lib/AsmParser/AsmParserState.cpp
@@ -273,7 +273,7 @@
 
 void AsmParserState::addUses(Value value, ArrayRef<SMLoc> locations) {
   // Handle the case where the value is an operation result.
-  if (OpResult result = value.dyn_cast<OpResult>()) {
+  if (OpResult result = dyn_cast<OpResult>(value)) {
     // Check to see if a definition for the parent operation has been recorded.
     // If one hasn't, we treat the provided value as a placeholder value that
     // will be refined further later.
Index: mlir/lib/AsmParser/Parser.cpp
===================================================================
--- mlir/lib/AsmParser/Parser.cpp
+++ mlir/lib/AsmParser/Parser.cpp
@@ -2255,7 +2255,7 @@
 
       // If the value isn't a forward reference, we also add the name of the op
       // to the detail.
-      if (auto result = frontValue.dyn_cast<OpResult>()) {
+      if (auto result = dyn_cast<OpResult>(frontValue)) {
         if (!forwardRefPlaceholders.count(result))
           detailOS << result.getOwner()->getName() << ": ";
       } else {
Index: mlir/lib/IR/AsmPrinter.cpp
===================================================================
--- mlir/lib/IR/AsmPrinter.cpp
+++ mlir/lib/IR/AsmPrinter.cpp
@@ -1009,7 +1009,7 @@
 
   // If this is an operation result, collect the head lookup value of the result
   // group and the result number of 'result' within that group.
-  if (OpResult result = value.dyn_cast<OpResult>())
+  if (OpResult result = dyn_cast<OpResult>(value))
     getResultIDAndNumber(result, lookupValue, resultNo);
 
   auto it = valueIDs.find(lookupValue);
Index: mlir/lib/IR/Dominance.cpp
===================================================================
--- mlir/lib/IR/Dominance.cpp
+++ mlir/lib/IR/Dominance.cpp
@@ -297,7 +297,7 @@
 bool DominanceInfo::properlyDominates(Value a, Operation *b) const {
   // block arguments properly dominate all operations in their own block, so
   // we use a dominates check here, not a properlyDominates check.
-  if (auto blockArg = a.dyn_cast<BlockArgument>())
+  if (auto blockArg = dyn_cast<BlockArgument>(a))
     return dominates(blockArg.getOwner(), b->getBlock());
 
   // `a` properlyDominates `b` if the operation defining `a` properlyDominates