[mlir] Update Values to use new casting infra

[nkreeger]

Summary

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

[lattner]

Awesome!! Please adopt this in a few places just to exercise the new logic. a wholesale swapover can be done in a separate patch, but it is good to show that the new syntax works.

[nkreeger]

Updated to include a few internal use-cases. Deferring wholesale changes to a later date (like the other MLIR casting changes).

[rriddle]

mlir/include/mlir/IR/Value.h

568–574

This comment doesn't look applicable here. Values don't cast using TypeID.

[lattner]

awesome, thank you!

[bzcheeseman]

LGTM with river's comment applied about the code comment. Thanks nick!

[nkreeger]

Updated comment to clarify Value uses getKind() instead of getTypeID() inside of Value::classof.

[nkreeger]

mlir/include/mlir/IR/Value.h

568–574

This comment doesn't look applicable here. Values don't cast using TypeID.

ack - done

mlir/include/mlir/IR/Value.h

 /// ValueImpl that is either owner by a block(in the case of a BlockArgument) or
 /// an Operation(in the case of an OpResult).
 class Value {
 public:
   constexpr Value(detail::ValueImpl *impl = nullptr) : impl(impl) {}
 
   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; }
   bool operator==(const Value &other) const { return impl == other.impl; }
   bool operator!=(const Value &other) const { return !(*this == other); }
 
   /// Return the type of this value.
   Type getType() const { return impl->getType(); }

 struct PointerLikeTypeTraits<mlir::OpResult>
     : public PointerLikeTypeTraits<mlir::Value> {
 public:
   static inline mlir::OpResult getFromVoidPointer(void *pointer) {
     return reinterpret_cast<mlir::detail::OpResultImpl *>(pointer);
   }
 };
 
+/// 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

void AsmParserState::addDefinition(BlockArgument blockArg, SMLoc location) {
 
   if (def.arguments.size() <= argIdx)
     def.arguments.resize(argIdx + 1);
   def.arguments[argIdx] = SMDefinition(convertIdLocToRange(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.
     Operation *parentOp = result.getOwner();
     auto existingIt = impl->operationToIdx.find(parentOp);
     if (existingIt == impl->operationToIdx.end()) {
       impl->placeholderValueUses[value].append(locations.begin(),
                                                locations.end());

mlir/lib/AsmParser/Parser.cpp

ParseResult OperationParser::codeCompleteSSAUse() {
   for (IsolatedSSANameScope &scope : isolatedNameScopes) {
     for (auto &it : scope.values) {
       if (it.second.empty())
         continue;
       Value frontValue = it.second.front().value;
 
       // 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 {
         detailOS << "arg #" << frontValue.cast<BlockArgument>().getArgNumber()
                  << ": ";
       }
 
       // Emit the type of the values to aid with completion selection.

mlir/lib/IR/AsmPrinter.cpp

if (!value) {
     return;
   }
 
   Optional<int> resultNo;
   auto lookupValue = value;
 
   // 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);
   if (it == valueIDs.end()) {
     stream << "<<UNKNOWN SSA VALUE>>";
     return;
   }
 

mlir/lib/IR/Dominance.cpp

 }
 
 /// Return true if the `a` value properly dominates operation `b`, i.e if the
 /// operation that defines `a` properlyDominates `b` and the operation that
 /// defines `a` does not contain `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
   // `b`, but `a` does not itself enclose `b` in one of its regions.
   return properlyDominatesImpl(a.getDefiningOp(), b, /*enclosingOpOk=*/false);
 }
 
 //===----------------------------------------------------------------------===//