[mlir] check interfaces are attached to the expected object

[ftynse]

Summary

Add static assertions into the various attachInterface methods, which are
used for adding external interface implementations to attributes, operations
and types, that ensure ExternalModel interface classes are instantiated for
the same concrete operation for the concrete base (potentially self) attribute
or type as they are attached to. FallbackModels remain usable for generic
interface models that should support more than one kind of entities.

[springerm]

Thx for implementing this. This will make debugging much easier from now.

mlir/include/mlir/IR/OpDefinition.h

#endif
   const void *getAsOpaquePointer() const {
     return static_cast<const void *>((Operation *)*this);
   }
   static ConcreteOpType getFromOpaquePointer(const void *pointer) {
     return ConcreteOpType(
         reinterpret_cast<Operation *>(const_cast<void *>(pointer)));
   }
 
-  /// Attach the given models as implementations of the corresponding interfaces
-  /// for the concrete operation.
+  /// Attach the given models as implementations of the corresponding
+  /// interfaces for the concrete operation.
   template <typename... Models>
   static void attachInterface(MLIRContext &context) {
     Optional<RegisteredOperationName> info = RegisteredOperationName::lookup(
         ConcreteType::getOperationName(), &context);
     if (!info)
       llvm::report_fatal_error(
           "Attempting to attach an interface to an unregistered operation " +
           ConcreteType::getOperationName() + ".");
+    (void)std::initializer_list<int>{(checkInterfaceTarget<Models>(), 0)...};
     info->attachInterface<Models...>();
   }
 
 private:
   /// Trait to check if T provides a 'fold' method for a single result op.
   template <typename T, typename... Args>
   using has_single_result_fold =
       decltype(std::declval<T>().fold(std::declval<ArrayRef<Attribute>>()));
private:
   using detect_has_fold = llvm::is_detected<has_fold, T>;
   /// Trait to check if T provides a 'print' method.
   template <typename T, typename... Args>
   using has_print =
       decltype(std::declval<T>().print(std::declval<OpAsmPrinter &>()));
   template <typename T>
   using detect_has_print = llvm::is_detected<has_print, T>;
 
+  /// Trait to check if T provides a 'ConcreteEntity' type alias.
+  template <typename T>
+  using has_concrete_entity_t = typename T::ConcreteEntity;
+
+  /// A struct-wrapped type alias to T::ConcreteEntity if provided and to
+  /// ConcreteType otherwise. This is akin to std::conditional but doesn't fail
+  /// on the missing typedef. Useful for checking if the interface is targeting
+  /// the right class.
+  template <typename T,
+            bool = llvm::is_detected<has_concrete_entity_t, T>::value>
+  struct InterfaceTargetOrOpT {
+    using type = typename T::ConcreteEntity;
+  };
+  template <typename T> struct InterfaceTargetOrOpT<T, false> {
+    using type = ConcreteType;
+  };
+
+  /// A hook for static assertion that the external interface model T is
+  /// targeting the concrete type of this op. The model can also be a fallback
+  /// model that works for every op.
+  template <typename T> static void checkInterfaceTarget() {
+    static_assert(std::is_same<typename InterfaceTargetOrOpT<T>::type,
+                               ConcreteType>::value,
+                  "attaching an interface to the wrong op kind");
+  }
+
   /// Returns an interface map containing the interfaces registered to this
   /// operation.
   static detail::InterfaceMap getInterfaceMap() {
     return detail::InterfaceMap::template get<Traits<ConcreteType>...>();
   }
 
   /// Return the internal implementations of each of the OperationName
   /// hooks.

mlir/include/mlir/IR/StorageUniquerSupport.h

public:
   template <typename... IfaceModels>
   static void attachInterface(MLIRContext &context) {
     typename ConcreteT::AbstractTy *abstract =
         ConcreteT::AbstractTy::lookupMutable(TypeID::get<ConcreteT>(),
                                              &context);
     if (!abstract)
       llvm::report_fatal_error("Registering an interface for an attribute/type "
                                "that is not itself registered.");
+    (void)std::initializer_list<int>{
+        (checkInterfaceTarget<IfaceModels>(), 0)...};
     abstract->interfaceMap.template insert<IfaceModels...>();
   }
 
   /// Get or create a new ConcreteT instance within the ctx. This
   /// function is guaranteed to return a non null object and will assert if
   /// the arguments provided are invalid.
   template <typename... Args>
   static ConcreteT get(MLIRContext *ctx, Args... args) {
protected:
 
   /// Default implementation that just returns success.
   template <typename... Args> static LogicalResult verify(Args... args) {
     return success();
   }
 
   /// Utility for easy access to the storage instance.
   ImplType *getImpl() const { return static_cast<ImplType *>(this->impl); }
+
+private:
+  /// Trait to check if T provides a 'ConcreteEntity' type alias.
+  template <typename T>
+  using has_concrete_entity_t = typename T::ConcreteEntity;
+
+  /// A struct-wrapped type alias to T::ConcreteEntity if provided and to
+  /// ConcreteT otherwise. This is akin to std::conditional but doesn't fail on
+  /// the missing typedef. Useful for checking if the interface is targeting the
+  /// right class.
+  template <typename T,
+            bool = llvm::is_detected<has_concrete_entity_t, T>::value>
+  struct IfaceTargetOrConcreteT {
+    using type = typename T::ConcreteEntity;
+  };
+  template <typename T>
+  struct IfaceTargetOrConcreteT<T, false> {
+    using type = ConcreteT;
+  };
+
+  /// A hook for static assertion that the external interface model T is
+  /// targeting a base class of the concrete attribute/type. The model can also
+  /// be a fallback model that works for every attribute/type.
+  template <typename T>
+  static void checkInterfaceTarget() {
+    static_assert(std::is_base_of<typename IfaceTargetOrConcreteT<T>::type,
+                                  ConcreteT>::value,
+                  "attaching an interface to the wrong attribute/type kind");
+  }
 };
 } // namespace detail
 } // namespace mlir
 
 #endif

mlir/tools/mlir-tblgen/OpInterfacesGen.cpp

for (const char *modelClass : {"Model", "FallbackModel"}) {
     os << "  };\n";
   }
 
   // Emit the template for the external model.
   os << "  template<typename ConcreteModel, typename " << valueTemplate
      << ">\n";
   os << "  class ExternalModel : public FallbackModel<ConcreteModel> {\n";
   os << "  public:\n";
+  os << "    using ConcreteEntity = " << valueTemplate << ";\n";
 
   // Emit declarations for methods that have default implementations. Other
   // methods are expected to be implemented by the concrete derived model.
   for (auto &method : interface.getMethods()) {
     if (!method.getDefaultImplementation())
       continue;
     os << "    ";
     if (method.isStatic())