[mlir] Update CallInterfaceCallable to use the new casting infra

[nkreeger]

Summary

This enables casting LLVM style for mlir::CallInterfaceCallable usage.

[rriddle]

Can you update the usages to use the new casting infra? There likely aren't many.

[lattner]

Nice Nick, +1 for updating in tree uses if there are any

[nkreeger]

Updated to fix callers with new dyn_cast usage.

[bzcheeseman]

Thanks Nick :)

mlir/include/mlir/Interfaces/CallInterfaces.h

 struct CallInterfaceCallable : public PointerUnion<SymbolRefAttr, Value> {
   using PointerUnion<SymbolRefAttr, Value>::PointerUnion;
 };
 } // namespace mlir
 
 /// Include the generated interface declarations.
 #include "mlir/Interfaces/CallInterfaces.h.inc"
 
+namespace llvm {
+
+template <typename To>
+struct CastInfo<To, mlir::CallInterfaceCallable>
+    : public CastInfo<To, mlir::CallInterfaceCallable::PointerUnion> {};
+
+} // namespace llvm
+
 #endif // MLIR_INTERFACES_CALLINTERFACES_H

mlir/lib/Interfaces/CallInterfaces.cpp

 
 /// Resolve the callable operation for given callee to a CallableOpInterface, or
 /// nullptr if a valid callable was not resolved. `symbolTable` is an optional
 /// parameter that will allow for using a cached symbol table for symbol lookups
 /// instead of performing an O(N) scan.
 Operation *
 CallOpInterface::resolveCallable(SymbolTableCollection *symbolTable) {
   CallInterfaceCallable callable = getCallableForCallee();
-  if (auto symbolVal = callable.dyn_cast<Value>())
+  if (auto symbolVal = dyn_cast<Value>(callable))
     return symbolVal.getDefiningOp();
 
   // If the callable isn't a value, lookup the symbol reference.
   auto symbolRef = callable.get<SymbolRefAttr>();
   if (symbolTable)
     return symbolTable->lookupNearestSymbolFrom(getOperation(), symbolRef);
   return SymbolTable::lookupNearestSymbolFrom(getOperation(), symbolRef);
 }
 
 //===----------------------------------------------------------------------===//
 // CallInterfaces
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Interfaces/CallInterfaces.cpp.inc"

mlir/lib/Transforms/Inliner.cpp

static void collectCallOps(iterator_range<Region::iterator> blocks,
   while (!worklist.empty()) {
     Block *block;
     std::tie(block, sourceNode) = worklist.pop_back_val();
 
     for (Operation &op : *block) {
       if (auto call = dyn_cast<CallOpInterface>(op)) {
         // TODO: Support inlining nested call references.
         CallInterfaceCallable callable = call.getCallableForCallee();
-        if (SymbolRefAttr symRef = callable.dyn_cast<SymbolRefAttr>()) {
+        if (SymbolRefAttr symRef = dyn_cast<SymbolRefAttr>(callable)) {
           if (!symRef.isa<FlatSymbolRefAttr>())
             continue;
         }
 
         CallGraphNode *targetNode = cg.resolveCallable(call, symbolTable);
         if (!targetNode->isExternal())
           calls.emplace_back(call, sourceNode, targetNode);
         continue;