[mlir][Interfaces] Add implicit casts from concrete operation types to the interfaces they implement.

[rriddle]

Summary

This removes the need to have an explicit cast<> given that we always know it isa instance of the interface.

mlir/include/mlir/Support/InterfaceSupport.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_SUPPORT_INTERFACESUPPORT_H
 #define MLIR_SUPPORT_INTERFACESUPPORT_H
 
 #include "mlir/Support/TypeID.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/TypeName.h"
-#include "llvm/Support/raw_ostream.h"
 
 namespace mlir {
 namespace detail {
 //===----------------------------------------------------------------------===//
 // Interface
 //===----------------------------------------------------------------------===//
 
 /// This class represents an abstract interface. An interface is a simplified
template <typename ConcreteType, typename ValueT, typename Traits,
           template <typename, template <typename> class> class BaseTrait>
 class Interface : public BaseType {
 public:
   using Concept = typename Traits::Concept;
   template <typename T> using Model = typename Traits::template Model<T>;
   using InterfaceBase =
       Interface<ConcreteType, ValueT, Traits, BaseType, BaseTrait>;
 
+  /// This is a special trait that registers a given interface with an object.
+  template <typename ConcreteT>
+  struct Trait : public BaseTrait<ConcreteT, Trait> {
+    using ModelT = Model<ConcreteT>;
+
+    /// Define an accessor for the ID of this interface.
+    static TypeID getInterfaceID() { return TypeID::get<ConcreteType>(); }
+  };
+
+  /// Construct an interface from an instance of the value type.
   Interface(ValueT t = ValueT())
       : BaseType(t), impl(t ? ConcreteType::getInterfaceFor(t) : nullptr) {
-    assert((!t || impl) &&
-           "instantiating an interface with an unregistered operation");
+    assert((!t || impl) && "expected value to provide interface instance");
+  }
+
+  /// Construct an interface instance from a type that implements this
+  /// interface's trait.
+  template <typename T, typename std::enable_if_t<
+                            std::is_base_of<Trait<T>, T>::value> * = nullptr>
+  Interface(T t)
+      : BaseType(t), impl(t ? ConcreteType::getInterfaceFor(t) : nullptr) {
+    assert((!t || impl) && "expected value to provide interface instance");
   }
 
   /// Support 'classof' by checking if the given object defines the concrete
   /// interface.
   static bool classof(ValueT t) { return ConcreteType::getInterfaceFor(t); }
 
   /// Define an accessor for the ID of this interface.
   static TypeID getInterfaceID() { return TypeID::get<ConcreteType>(); }
 
-  /// This is a special trait that registers a given interface with an object.
-  template <typename ConcreteT>
-  struct Trait : public BaseTrait<ConcreteT, Trait> {
-    using ModelT = Model<ConcreteT>;
-
-    /// Define an accessor for the ID of this interface.
-    static TypeID getInterfaceID() { return TypeID::get<ConcreteType>(); }
-  };
-
 protected:
   /// Get the raw concept in the correct derived concept type.
   const Concept *getImpl() const { return impl; }
   Concept *getImpl() { return impl; }
 
 private:
   /// A pointer to the impl concept object.
   Concept *impl;

mlir/lib/Dialect/Linalg/Transforms/FusionOnTensors.cpp

 /// Based on the type of `op` create a linalg op of the same type, i.e. if `op`
 /// is a linalg.generic operation, the create a `linalg.generic` operation with
 /// the given `args`. Expects `op` to be `linalg.generic` or
 /// `linalg.indexed_generic`.
 template <typename... Args>
 static LinalgOp createLinalgOpOfSameType(LinalgOp op, PatternRewriter &rewriter,
                                          Args... args) {
   if (isa<GenericOp>(op.getOperation()))
-    return cast<LinalgOp>(rewriter.create<GenericOp>(args...).getOperation());
+    return rewriter.create<GenericOp>(args...);
   if (isa<IndexedGenericOp>(op.getOperation()))
-    return cast<LinalgOp>(
-        rewriter.create<IndexedGenericOp>(args...).getOperation());
+    return rewriter.create<IndexedGenericOp>(args...);
   llvm_unreachable(
       "expected only linalg.generic or linalg.indexed_generic ops");
   return nullptr;
 }
 
 /// Conditions for folding a generic/indexed-generic operation with a reshape op
 /// by expanding the iteration space dimensionality for tensor operations. These
 /// are preconditions assumed by `foldReshapeByDimExpansion` which implements