[mlir] Update Values to use new casting infra

This allows for using the llvm namespace cast methods instead of the ones on the Value class. The Value class method are kept for now, but we'll want to remove these eventually (with a really long lead time).

Related change: https://reviews.llvm.org/D134327

Differential Revision: https://reviews.llvm.org/D135870

mlir/include/mlir/IR/Value.h

@@ -88,26 +88,22 @@ class Value {
 
   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 @@ struct PointerLikeTypeTraits<mlir::OpResult>
   }
 };
 
+/// 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

mlir/lib/AsmParser/AsmParserState.cpp

@@ -273,7 +273,7 @@ void AsmParserState::addDefinition(BlockArgument blockArg, SMLoc location) {
 
 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.

mlir/lib/AsmParser/Parser.cpp

@@ -2255,7 +2255,7 @@ ParseResult OperationParser::codeCompleteSSAUse() {
 
       // 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 {

mlir/lib/IR/AsmPrinter.cpp

@@ -1009,7 +1009,7 @@ void SSANameState::printValueID(Value value, bool printResultNo,
 
   // 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);

mlir/lib/IR/Dominance.cpp

@@ -297,7 +297,7 @@ bool DominanceInfo::properlyDominatesImpl(Operation *a, Operation *b,
 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