[mlir] Add support for interface inheritance

[rriddle]

Summary

This allows for interfaces to define a set of "base classes",
which are interfaces whose methods/extra class decls/etc.
should be inherited by the derived interface. This more
easily enables combining interfaces and their dependencies,
without lots of awkard casting. Additional implicit conversion
operators also greatly simplify the conversion process.

One other aspect of this "inheritance" is that we also implicitly
add the base interfaces to the attr/op/type. The user can still
add them manually if desired, but this should help remove some
of the boiler plate when an interface has dependencies.

See https://discourse.llvm.org/t/interface-inheritance-and-dependencies-interface-method-visibility-interface-composition

[jpienaar]

mlir/docs/Interfaces.md

667

instills?

669

I think this is something to expand on. What happens with "multiple inheritance" where there are overlapping method names?

mlir/include/mlir/IR/OpBase.td

2028

Should we default this list to be empty? (you've done that below but was wondering even here in case someone uses this raw base class)

mlir/include/mlir/Support/InterfaceSupport.h

231

Could you file github issue for this?

mlir/test/mlir-tblgen/op-interface.td

37

I think it would be good to have a unit test: the C++ API for usage and how inheritance works/convenience it affords I don't think is clear here or in the doc. A unit test I think would be great way to show how to use these.

mlir/tools/mlir-tblgen/OpInterfacesGen.cpp

205

This is not strictly correct is it? E.g., we could be including this in a namespace with the same nesting below as exists at top level.

[nicolasvasilache]

Generally looks good, +1 for some C++ test that exercises the behavior.

Thanks River!

[rriddle]

mlir/test/mlir-tblgen/op-interface.td

37

What do you have in mind exactly? The C++ aspect is already tested via TestInterfaces.td (it moves existing methods to be tested via inheritance). Examples are probably best left for docs (or in-tree examples, which the followup handles with FuncOpInterface).

mlir/tools/mlir-tblgen/OpInterfacesGen.cpp

205

I didn't change this at all. If you don't drop it, stuff explodes:

llvm-project/build/tools/mlir/include/mlir/IR/OpAsmInterface.cpp.inc:71:1: error: no member named 'mlir' in 'llvm::StringRef'; did you mean simply 'mlir'?
::llvm::StringRef ::mlir::OpAsmOpInterface::getDefaultDialect() {
^~~~~~~~~~~~~~~~~~~~~~~~
mlir
llvm-project/mlir/include/mlir/IR/Verifier.h:12:11: note: 'mlir' declared here
namespace mlir {

[jpienaar]

Thanks, LGTM

mlir/docs/Interfaces.md

669

Very nice examples. Could you add what happens if the interfaces have overlapping method names?

mlir/test/mlir-tblgen/op-interface.td

37

I was thinking of like hello-world C++ destruction order examples where one shows code and says what method will be actually called (throw in a couple of casts to show possible/inheritance gives you the Isa behavior of both etc). It's more an example that runs than anything else to show how fits together. You are correct follow up does add one, but was thinking this could be nice local example (you have expanded the docs a lot since so less of a need esp along with follow up).

mlir/docs/Interfaces.md

 ```
 
 Providing a definition of the `AttrInterface`, `OpInterface`, or `TypeInterface`
 class will auto-generate the C++ classes for the interface. Interfaces are
 comprised of the following components:
 
 *   C++ Class Name (Provided via template parameter)
     -   The name of the C++ interface class.
+*   Interface Base Classes
+    -   A set of interfaces that the interface class should derived from. See
+        [Interface Inheritance](#interface-inheritance) below for more details.
 *   Description (`description`)
     -   A string description of the interface, its invariants, example usages,
         etc.
 *   C++ Namespace (`cppNamespace`)
     -   The C++ namespace that the interface class should be generated in.
 *   Methods (`methods`)
     -   The list of interface hook methods that are defined by the IR object.
     -   The structure of these methods is defined below.

 `OpInterface` classes may additionally contain the following:
 
 *   Verifier (`verify`)
     -   A C++ code block containing additional verification applied to the
         operation that the interface is attached to.
     -   The structure of this code block corresponds 1-1 with the structure of a
         [`Trait::verifyTrait`](Traits.md) method.
 
+##### Interface Methods
+
 There are two types of methods that can be used with an interface,
 `InterfaceMethod` and `StaticInterfaceMethod`. They are both comprised of the
 same core components, with the distinction that `StaticInterfaceMethod` models a
 static method on the derived IR object.
 
 Interface methods are comprised of the following components:
 
 *   Description

 // Methods that have a default implementation do not have declarations
 // generated. If an operation wishes to override the default behavior, it can
 // explicitly specify the method that it wishes to override. This will force
 // the generation of a declaration for those methods.
 def OpWithOverrideInferTypeInterfaceOp : Op<...
     [DeclareOpInterfaceMethods<MyInterface, ["getNumWithDefault"]>]> { ... }
 ```
 
+##### Interface Inheritance
+
+Interfaces also support a limited form of inheritance, which allows for
+building upon pre-existing interfaces in a way similar to that of classes in
+programming languages like C++. This more easily allows for building modular
+interfaces, without suffering from the pain of lots of explicit casting. To
+enable inheritance, an interface simply needs to provide the desired set of
+base classes in its definition. For example:
+
+```tablegen
+def MyBaseInterface : OpInterface<"MyBaseInterface"> {
+  ...
+}
+
+def MyInterface : OpInterface<"MyInterface", [MyBaseInterface]> {
+  ...
+}
+```
+
+This will result in `MyInterface` inheriting various components from
+`MyBaseInterface`, namely its interface methods and extra class declarations.
+Given that these inherited components are comprised of opaque C++ blobs, we
+cannot properly sandbox the names. As such, it's important to ensure that inherited
+components do not create name overlaps, as these will result in errors during
+interface generation.
+
+`MyInterface` will also implicitly inherit any base classes defined on
+`MyBaseInterface` as well. It's important to note, however, that there is only
+ever one instance of each interface for a given attribute, operation, or type.
+Inherited interface methods simplify forward to base interface implementation.
+This produces a simpler system overall, and also removes any potential problems
+surrounding "diamond inheritance". The interfaces on an attribute/op/type can be
+thought of as comprising a set, with each interface (including base interfaces)
+uniqued within this set and referenced elsewhere as necessary.
+
+When adding an interface with inheritance to an attribute, operation, or type,
+all of the base interfaces are also implicitly added as well. The user may still
+manually specify the base interfaces if they desire, such as for use with the
+`Declare<Attr|Op|Type>InterfaceMethods` helper classes.
+
+If our interface were to be specified as:
+
+```tablegen
+def MyBaseInterface : OpInterface<"MyBaseInterface"> {
+  ...
+}
+
+def MyOtherBaseInterface : OpInterface<MyOtherBaseInterface, [MyBaseInterface]> {
+  ...
+}
+
+def MyInterface : OpInterface<"MyInterface", [MyBaseInterface, MyOtherBaseInterface]> {
+  ...
+}
+```
+
+An operation with `MyInterface` attached, would have the following interfaces added:
+
+* MyBaseInterface, MyOtherBaseInterface, MyInterface
+
+The methods from `MyBaseInterface` in both `MyInterface` and `MyOtherBaseInterface` would
+forward to a single unique implementation for the operation.
+
+##### Generation
+
 Once the interfaces have been defined, the C++ header and source files can be
 generated using the `--gen-<attr|op|type>-interface-decls` and
 `--gen-<attr|op|type>-interface-defs` options with mlir-tblgen. Note that when
 generating interfaces, mlir-tblgen will only generate interfaces defined in
 the top-level input `.td` file. This means that any interfaces that are
 defined within include files will not be considered for generation.
 
 Note: Existing operation interfaces defined in C++ can be accessed in the ODS

mlir/include/mlir/IR/OpBase.td

 // should be named as `result_segment_sizes`.
 def AttrSizedResultSegments  :
   NativeOpTrait<"AttrSizedResultSegments">, StructuralOpTrait;
 
 // Op attached regions have no arguments
 def NoRegionArguments : NativeOpTrait<"NoRegionArguments">, StructuralOpTrait;
 
 //===----------------------------------------------------------------------===//
-// OpInterface definitions
+// Interface definitions
 //===----------------------------------------------------------------------===//
 
 // Marker used to identify the argument list for an op or interface method.
 def ins;
 
 // This class represents a typed argument with optional default value for C
 // function signatures, e.g. builders or methods.
 class CArg<string ty, string value = ""> {

 // This class represents a single static interface method.
 class StaticInterfaceMethod<string desc, string retTy, string methodName,
                             dag args = (ins), code methodBody = [{}],
                             code defaultImplementation = [{}]>
     : InterfaceMethod<desc, retTy, methodName, args, methodBody,
                       defaultImplementation>;
 
 // Interface represents a base interface.
-class Interface<string name> {
+class Interface<string name, list<Interface> baseInterfacesArg = []> {
   // A human-readable description of what this interface does.
   string description = "";
 
   // The name given to the c++ interface class.
   string cppInterfaceName = name;
 
   // The C++ namespace that this interface should be placed into.
   //
class Interface<string name, list<Interface> baseInterfacesArg = []> {
   code extraSharedClassDeclaration = "";
 
   // An optional code block for adding additional "classof" logic. This can
   // be used to better enable "optional" interfaces, where an entity only
   // implements the interface if some dynamic characteristic holds.
   // `$_attr`/`$_op`/`$_type` may be used to refer to an instance of the
   // entity being checked.
   code extraClassOf = "";
+
+  // An optional set of base interfaces that this interface
+  // "derives" from.
+  list<Interface> baseInterfaces = baseInterfacesArg;
 }
 
 // AttrInterface represents an interface registered to an attribute.
-class AttrInterface<string name> : Interface<name>, InterfaceTrait<name>,
-  Attr<CPred<"$_self.isa<"
-    # !if(!empty(cppNamespace),"", cppNamespace # "::") # name # ">()">,
-      name # " instance">
-{
+class AttrInterface<string name, list<Interface> baseInterfaces = []>
+  : Interface<name, baseInterfaces>, InterfaceTrait<name>,
+    Attr<CPred<"$_self.isa<"
+      # !if(!empty(cppNamespace),"", cppNamespace # "::") # name # ">()">,
+      name # " instance"
+    > {
   let storageType = !if(!empty(cppNamespace), "", cppNamespace # "::") # name;
   let returnType = storageType;
   let convertFromStorage = "$_self";
 }
 
 // OpInterface represents an interface registered to an operation.
-class OpInterface<string name> : Interface<name>, OpInterfaceTrait<name>;
+class OpInterface<string name, list<Interface> baseInterfaces = []>
+  : Interface<name, baseInterfaces>, OpInterfaceTrait<name>;
 
 // TypeInterface represents an interface registered to a type.
-class TypeInterface<string name> : Interface<name>, InterfaceTrait<name>,
-  Type<CPred<"$_self.isa<"
-    # !if(!empty(cppNamespace),"", cppNamespace # "::") # name # ">()">,
+class TypeInterface<string name, list<Interface> baseInterfaces = []>
+  : Interface<name, baseInterfaces>, InterfaceTrait<name>,
+    Type<CPred<"$_self.isa<"
+      # !if(!empty(cppNamespace),"", cppNamespace # "::") # name # ">()">,
       name # " instance",
-        !if(!empty(cppNamespace),"", cppNamespace # "::") # name>;
+      !if(!empty(cppNamespace),"", cppNamespace # "::") # name
+    >;
 
 // Whether to declare the interface methods in the user entity's header. This
 // class simply wraps an Interface but is used to indicate that the method
 // declarations should be generated. This class takes an optional set of methods
 // that should have declarations generated even if the method has a default
 // implementation.
 class DeclareInterfaceMethods<list<string> overridenMethods = []> {
     // This field contains a set of method names that should always have their
     // declarations generated. This allows for generating declarations for
     // methods with default implementations that need to be overridden.
     list<string> alwaysOverriddenMethods = overridenMethods;
 }
 class DeclareAttrInterfaceMethods<AttrInterface interface,
                                   list<string> overridenMethods = []>
       : DeclareInterfaceMethods<overridenMethods>,
-        AttrInterface<interface.cppInterfaceName> {
+        AttrInterface<interface.cppInterfaceName, interface.baseInterfaces> {
     let description = interface.description;
     let cppInterfaceName = interface.cppInterfaceName;
     let cppNamespace = interface.cppNamespace;
     let methods = interface.methods;
+    let baseInterfaces = interface.baseInterfaces;
 }
 class DeclareOpInterfaceMethods<OpInterface interface,
                                 list<string> overridenMethods = []>
       : DeclareInterfaceMethods<overridenMethods>,
-        OpInterface<interface.cppInterfaceName> {
+        OpInterface<interface.cppInterfaceName, interface.baseInterfaces> {
     let description = interface.description;
     let cppInterfaceName = interface.cppInterfaceName;
     let cppNamespace = interface.cppNamespace;
     let methods = interface.methods;
+    let baseInterfaces = interface.baseInterfaces;
 }
 class DeclareTypeInterfaceMethods<TypeInterface interface,
                                   list<string> overridenMethods = []>
       : DeclareInterfaceMethods<overridenMethods>,
-        TypeInterface<interface.cppInterfaceName> {
+        TypeInterface<interface.cppInterfaceName, interface.baseInterfaces> {
     let description = interface.description;
     let cppInterfaceName = interface.cppInterfaceName;
     let cppNamespace = interface.cppNamespace;
     let methods = interface.methods;
+    let baseInterfaces = interface.baseInterfaces;
 }
 
 //===----------------------------------------------------------------------===//
 // Op definitions
 //===----------------------------------------------------------------------===//
 
 // Marker used to identify the result list for an op.
 def outs;

mlir/include/mlir/IR/OperationSupport.h

public:
   /// directly.
   template <typename T>
   typename T::Concept *getInterface() const {
     return getImpl()->getInterfaceMap().lookup<T>();
   }
 
   /// Attach the given models as implementations of the corresponding
   /// interfaces for the concrete operation.
-  template <typename... Models> void attachInterface() {
-    getImpl()->getInterfaceMap().insert<Models...>();
+  template <typename... Models>
+  void attachInterface() {
+    getImpl()->getInterfaceMap().insertModels<Models...>();
   }
 
   /// Returns true if this operation has the given interface registered to it.
   template <typename T>
   bool hasInterface() const {
     return hasInterface(TypeID::get<T>());
   }
   bool hasInterface(TypeID interfaceID) const {

 /// This is a "type erased" representation of a registered operation. This
 /// should only be used by things like the AsmPrinter and other things that need
 /// to be parameterized by generic operation hooks. Most user code should use
 /// the concrete operation types.
 class RegisteredOperationName : public OperationName {
 public:
   /// Implementation of the InterfaceConcept for operation APIs that forwarded
   /// to a concrete op implementation.
-  template <typename ConcreteOp> struct Model : public Impl {
+  template <typename ConcreteOp>
+  struct Model : public Impl {
     Model(Dialect *dialect)
         : Impl(ConcreteOp::getOperationName(), dialect,
                TypeID::get<ConcreteOp>(), ConcreteOp::getInterfaceMap()) {}
     LogicalResult foldHook(Operation *op, ArrayRef<Attribute> attrs,
                            SmallVectorImpl<OpFoldResult> &results) final {
       return ConcreteOp::getFoldHookFn()(op, attrs, results);
     }
     void getCanonicalizationPatterns(RewritePatternSet &set,
public:
   /// Lookup the registered operation information for the given operation.
   /// Returns std::nullopt if the operation isn't registered.
   static std::optional<RegisteredOperationName> lookup(StringRef name,
                                                        MLIRContext *ctx);
 
   /// Register a new operation in a Dialect object.
   /// This constructor is used by Dialect objects when they register the list
   /// of operations they contain.
-  template <typename T> static void insert(Dialect &dialect) {
+  template <typename T>
+  static void insert(Dialect &dialect) {
     insert(std::make_unique<Model<T>>(&dialect), T::getAttributeNames());
   }
   /// The use of this method is in general discouraged in favor of
   /// 'insert<CustomOp>(dialect)'.
   static void insert(std::unique_ptr<OperationName::Impl> ownedImpl,
                      ArrayRef<StringRef> attrNames);
 
   /// Return the dialect this operation is registered to.

mlir/include/mlir/IR/StorageUniquerSupport.h

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.");
 
     (checkInterfaceTarget<IfaceModels>(), ...);
-    abstract->interfaceMap.template insert<IfaceModels...>();
+    abstract->interfaceMap.template insertModels<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) {
     // Ensure that the invariants are correct for construction.

mlir/include/mlir/Support/InterfaceSupport.h

public:
   Interface(T t)
       : BaseType(t),
         conceptImpl(t ? ConcreteType::getInterfaceFor(t) : nullptr) {
     assert((!t || conceptImpl) &&
            "expected value to provide interface instance");
   }
 
   /// Constructor for a known concept.
-  Interface(ValueT t, Concept *conceptImpl)
-      : BaseType(t), conceptImpl(conceptImpl) {
+  Interface(ValueT t, const Concept *conceptImpl)
+      : BaseType(t), conceptImpl(const_cast<Concept *>(conceptImpl)) {
     assert(!t || ConcreteType::getInterfaceFor(t) == conceptImpl);
   }
 
   /// Constructor for DenseMapInfo's empty key and tombstone key.
   Interface(ValueT t, std::nullptr_t) : BaseType(t), conceptImpl(nullptr) {}
 
   /// Support 'classof' by checking if the given object defines the concrete
   /// interface.

 template <template <class> class Pred, size_t N, typename T, typename... Us>
 struct count_if_t_impl<Pred, N, T, Us...>
     : public std::integral_constant<
           size_t,
           count_if_t_impl<Pred, N + (Pred<T>::value ? 1 : 0), Us...>::value> {};
 template <template <class> class Pred, typename... Ts>
 using count_if_t = count_if_t_impl<Pred, 0, Ts...>;
 
-namespace {
-/// Type trait indicating whether all template arguments are
-/// trivially-destructible.
-template <typename... Args>
-struct all_trivially_destructible;
-
-template <typename Arg, typename... Args>
-struct all_trivially_destructible<Arg, Args...> {
-  static constexpr const bool value =
-      std::is_trivially_destructible<Arg>::value &&
-      all_trivially_destructible<Args...>::value;
-};
-
-template <>
-struct all_trivially_destructible<> {
-  static constexpr const bool value = true;
-};
-} // namespace
-
 /// This class provides an efficient mapping between a given `Interface` type,
 /// and a particular implementation of its concept.
 class InterfaceMap {
   /// Trait to check if T provides a static 'getInterfaceID' method.
   template <typename T, typename... Args>
   using has_get_interface_id = decltype(T::getInterfaceID());
   template <typename T>
   using detect_get_interface_id = llvm::is_detected<has_get_interface_id, T>;
   template <typename... Types>
   using num_interface_types_t = count_if_t<detect_get_interface_id, Types...>;
 
+  /// Trait to check if T provides a 'initializeInterfaceConcept' method.
+  template <typename T, typename... Args>
+  using has_initialize_method =
+      decltype(std::declval<T>().initializeInterfaceConcept(
+          std::declval<InterfaceMap &>()));
+  template <typename T>
+  using detect_initialize_method = llvm::is_detected<has_initialize_method, T>;
+
 public:
+  InterfaceMap() = default;
   InterfaceMap(InterfaceMap &&) = default;
   InterfaceMap &operator=(InterfaceMap &&rhs) {
     for (auto &it : interfaces)
       free(it.second);
     interfaces = std::move(rhs.interfaces);
     return *this;
   }
   ~InterfaceMap() {
     for (auto &it : interfaces)
       free(it.second);
   }
 
   /// Construct an InterfaceMap with the given set of template types. For
   /// convenience given that object trait lists may contain other non-interface
   /// types, not all of the types need to be interfaces. The provided types that
   /// do not represent interfaces are not added to the interface map.
   template <typename... Types>
   static InterfaceMap get() {
     constexpr size_t numInterfaces = num_interface_types_t<Types...>::value;
     if constexpr (numInterfaces == 0)
       return InterfaceMap();
 
-    std::array<std::pair<TypeID, void *>, numInterfaces> elements;
-    std::pair<TypeID, void *> *elementIt = elements.data();
-    (void)elementIt;
-    (addModelAndUpdateIterator<Types>(elementIt), ...);
-    return InterfaceMap(elements);
+    InterfaceMap map;
+    (map.insertPotentialInterface<Types>(), ...);
+    return map;
   }
 
   /// Returns an instance of the concept object for the given interface if it
   /// was registered to this map, null otherwise.
   template <typename T>
   typename T::Concept *lookup() const {
     return reinterpret_cast<typename T::Concept *>(lookup(T::getInterfaceID()));
   }
 
   /// Returns true if the interface map contains an interface for the given id.
   bool contains(TypeID interfaceID) const { return lookup(interfaceID); }
 
-  /// Create an InterfaceMap given with the implementation of the interfaces.
-  /// The use of this constructor is in general discouraged in favor of
-  /// 'InterfaceMap::get<InterfaceA, ...>()'.
-  InterfaceMap(MutableArrayRef<std::pair<TypeID, void *>> elements);
-
-  /// Insert the given models as implementations of the corresponding interfaces
-  /// for the concrete attribute class.
+  /// Insert the given interface models.
   template <typename... IfaceModels>
-  void insert() {
-    static_assert(all_trivially_destructible<IfaceModels...>::value,
-                  "interface models must be trivially destructible");
-    std::pair<TypeID, void *> elements[] = {
-        std::make_pair(IfaceModels::Interface::getInterfaceID(),
-                       new (malloc(sizeof(IfaceModels))) IfaceModels())...};
-    insert(elements);
+  void insertModels() {
+    (insertModel<IfaceModels>(), ...);
   }
 
 private:
-  InterfaceMap() = default;
-
-  /// Assign the interface model of the type to the given opaque element
-  /// iterator and increment it.
+  /// Insert the given interface type into the map, ignoring it if it doesn't
+  /// actually represent an interface.
   template <typename T>
-  static inline std::enable_if_t<detect_get_interface_id<T>::value>
-  addModelAndUpdateIterator(std::pair<TypeID, void *> *&elementIt) {
-    *elementIt = {T::getInterfaceID(), new (malloc(sizeof(typename T::ModelT)))
-                                           typename T::ModelT()};
-    ++elementIt;
-  }
-  /// Overload when `T` isn't an interface.
-  template <typename T>
-  static inline std::enable_if_t<!detect_get_interface_id<T>::value>
-  addModelAndUpdateIterator(std::pair<TypeID, void *> *&) {}
-
-  /// Insert the given set of interface models into the interface map.
-  void insert(ArrayRef<std::pair<TypeID, void *>> elements);
+  inline void insertPotentialInterface() {
+    if constexpr (detect_get_interface_id<T>::value)
+      insertModel<typename T::ModelT>();
+  }
+
+  /// Insert the given interface model into the map.
+  template <typename InterfaceModel>
+  void insertModel() {
+    // FIXME(#59975): Uncomment this when SPIRV no longer awkwardly reimplements
+    // interfaces in a way that isn't clean/compatible.
+    // static_assert(std::is_trivially_destructible_v<InterfaceModel>,
+    //               "interface models must be trivially destructible");
+
+    // Build the interface model, optionally initializing if necessary.
+    InterfaceModel *model =
+        new (malloc(sizeof(InterfaceModel))) InterfaceModel();
+    if constexpr (detect_initialize_method<InterfaceModel>::value)
+      model->initializeInterfaceConcept(*this);
+
+    insert(InterfaceModel::Interface::getInterfaceID(), model);
+  }
+  /// Insert the given set of interface id and concept implementation into the
+  /// interface map.
+  void insert(TypeID interfaceId, void *conceptImpl);
 
   /// Compare two TypeID instances by comparing the underlying pointer.
   static bool compare(TypeID lhs, TypeID rhs) {
     return lhs.getAsOpaquePointer() < rhs.getAsOpaquePointer();
   }
 
   /// Returns an instance of the concept object for the given interface id if it
   /// was registered to this map, null otherwise.

mlir/include/mlir/TableGen/Interfaces.h

 //===- Interfaces.h - Interface wrapper classes -----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TABLEGEN_INTERFACES_H_
 #define MLIR_TABLEGEN_INTERFACES_H_
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator.h"
 
 namespace llvm {
 class Init;
 class Record;
 } // namespace llvm
 
 namespace mlir {
 namespace tblgen {

 // Interface
 //===----------------------------------------------------------------------===//
 
 // Wrapper class with helper methods for accessing Interfaces defined in
 // TableGen.
 class Interface {
 public:
   explicit Interface(const llvm::Record *def);
+  Interface(const Interface &rhs) : def(rhs.def), methods(rhs.methods) {
+    for (auto &base : rhs.baseInterfaces)
+      baseInterfaces.push_back(std::make_unique<Interface>(*base));
+  }
 
   // Return the name of this interface.
   StringRef getName() const;
 
+  // Returns this interface's name prefixed with namespaces.
+  std::string getFullyQualifiedName() const;
+
   // Return the C++ namespace of this interface.
   StringRef getCppNamespace() const;
 
   // Return the methods of this interface.
   ArrayRef<InterfaceMethod> getMethods() const;
 
   // Return the description of this method if it has one.
   std::optional<StringRef> getDescription() const;
public:
   std::optional<StringRef> getExtraSharedClassDeclaration() const;
 
   // Return the extra classof method code.
   std::optional<StringRef> getExtraClassOf() const;
 
   // Return the verify method body if it has one.
   std::optional<StringRef> getVerify() const;
 
+  // Return the base interfaces of this interface.
+  auto getBaseInterfaces() const {
+    return llvm::make_pointee_range(baseInterfaces);
+  }
+
   // If there's a verify method, return if it needs to access the ops in the
   // regions.
   bool verifyWithRegions() const;
 
   // Returns the Tablegen definition this interface was constructed from.
   const llvm::Record &getDef() const { return *def; }
 
 private:
   // The TableGen definition of this interface.
   const llvm::Record *def;
 
   // The methods of this interface.
   SmallVector<InterfaceMethod, 8> methods;
+
+  // The base interfaces of this interface.
+  SmallVector<std::unique_ptr<Interface>> baseInterfaces;
 };
 
 // An interface that is registered to an Attribute.
 struct AttrInterface : public Interface {
   using Interface::Interface;
 
   static bool classof(const Interface *interface);
 };

mlir/lib/IR/ExtensibleDialect.cpp

DynamicOpDefinition::DynamicOpDefinition(
     OperationName::ParseAssemblyFn &&parseFn,
     OperationName::PrintAssemblyFn &&printFn,
     OperationName::FoldHookFn &&foldHookFn,
     GetCanonicalizationPatternsFn &&getCanonicalizationPatternsFn,
     OperationName::PopulateDefaultAttrsFn &&populateDefaultAttrsFn)
     : Impl(StringAttr::get(dialect->getContext(),
                            (dialect->getNamespace() + "." + name).str()),
            dialect, dialect->allocateTypeID(),
-           /*interfaceMap=*/detail::InterfaceMap(std::nullopt)),
+           /*interfaceMap=*/detail::InterfaceMap()),
       verifyFn(std::move(verifyFn)), verifyRegionFn(std::move(verifyRegionFn)),
       parseFn(std::move(parseFn)), printFn(std::move(printFn)),
       foldHookFn(std::move(foldHookFn)),
       getCanonicalizationPatternsFn(std::move(getCanonicalizationPatternsFn)),
       populateDefaultAttrsFn(std::move(populateDefaultAttrsFn)) {
   typeID = dialect->allocateTypeID();
 }
 

mlir/lib/IR/MLIRContext.cpp

OperationName::OperationName(StringRef name, MLIRContext *context) {
   // Acquire a writer-lock so that we can safely create the new instance.
   ScopedWriterLock lock(ctxImpl.operationInfoMutex, isMultithreadingEnabled);
 
   auto it = ctxImpl.operations.insert({name, nullptr});
   if (it.second) {
     auto nameAttr = StringAttr::get(context, name);
     it.first->second = std::make_unique<UnregisteredOpModel>(
         nameAttr, nameAttr.getReferencedDialect(), TypeID::get<void>(),
-        detail::InterfaceMap(std::nullopt));
+        detail::InterfaceMap());
   }
   impl = it.first->second.get();
 }
 
 StringRef OperationName::getDialectNamespace() const {
   if (Dialect *dialect = getDialect())
     return dialect->getNamespace();
   return getStringRef().split('.').first;

mlir/lib/Support/InterfaceSupport.cpp

 #include "mlir/Support/InterfaceSupport.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "interfaces"
 
 using namespace mlir;
 
-detail::InterfaceMap::InterfaceMap(
-    MutableArrayRef<std::pair<TypeID, void *>> elements)
-    : interfaces(elements.begin(), elements.end()) {
-  llvm::sort(interfaces, [](const auto &lhs, const auto &rhs) {
-    return compare(lhs.first, rhs.first);
-  });
-}
-
-void detail::InterfaceMap::insert(
-    ArrayRef<std::pair<TypeID, void *>> elements) {
+void detail::InterfaceMap::insert(TypeID interfaceId, void *conceptImpl) {
   // Insert directly into the right position to keep the interfaces sorted.
-  for (auto &element : elements) {
-    TypeID id = element.first;
-    auto *it = llvm::lower_bound(interfaces, id, [](const auto &it, TypeID id) {
+  auto *it =
+      llvm::lower_bound(interfaces, interfaceId, [](const auto &it, TypeID id) {
         return compare(it.first, id);
       });
-    if (it != interfaces.end() && it->first == id) {
-      LLVM_DEBUG(llvm::dbgs() << "Ignoring repeated interface registration");
-      free(element.second);
-      continue;
-    }
-    interfaces.insert(it, element);
+  if (it != interfaces.end() && it->first == interfaceId) {
+    free(conceptImpl);
+    return;
   }
+  interfaces.insert(it, {interfaceId, conceptImpl});
 }

mlir/lib/TableGen/AttrOrTypeDef.cpp

 //===- AttrOrTypeDef.cpp - AttrOrTypeDef wrapper classes ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/AttrOrTypeDef.h"
 #include "mlir/TableGen/Dialect.h"
+#include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
for (llvm::Init *init : builderList->getValues()) {
       builders.emplace_back(builder);
     }
   }
 
   // Populate the traits.
   if (auto *traitList = def->getValueAsListInit("traits")) {
     SmallPtrSet<const llvm::Init *, 32> traitSet;
     traits.reserve(traitSet.size());
-    for (auto *traitInit : *traitList)
-      if (traitSet.insert(traitInit).second)
+    llvm::unique_function<void(llvm::ListInit *)> processTraitList =
+        [&](llvm::ListInit *traitList) {
+          for (auto *traitInit : *traitList) {
+            if (!traitSet.insert(traitInit).second)
+              continue;
+
+            // If this is an interface, add any bases to the trait list.
+            auto *traitDef = cast<llvm::DefInit>(traitInit)->getDef();
+            if (traitDef->isSubClassOf("Interface")) {
+              if (auto *bases = traitDef->getValueAsListInit("baseInterfaces"))
+                processTraitList(bases);
+            }
+
             traits.push_back(Trait::create(traitInit));
           }
+        };
+    processTraitList(traitList);
+  }
 
   // Populate the parameters.
   if (auto *parametersDag = def->getValueAsDag("parameters")) {
     for (unsigned i = 0, e = parametersDag->getNumArgs(); i < e; ++i)
       parameters.push_back(AttrOrTypeParameter(parametersDag, i));
   }
 
   // Verify the use of the mnemonic field.

mlir/lib/TableGen/Interfaces.cpp

 //===- Interfaces.cpp - Interface classes ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/Interfaces.h"
+#include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 

 //===----------------------------------------------------------------------===//
 // Interface
 //===----------------------------------------------------------------------===//
 
 Interface::Interface(const llvm::Record *def) : def(def) {
   assert(def->isSubClassOf("Interface") &&
          "must be subclass of TableGen 'Interface' class");
 
+  // Initialize the interface methods.
   auto *listInit = dyn_cast<llvm::ListInit>(def->getValueInit("methods"));
   for (llvm::Init *init : listInit->getValues())
     methods.emplace_back(cast<llvm::DefInit>(init)->getDef());
+
+  // Initialize the interface base classes.
+  auto *basesInit =
+      dyn_cast<llvm::ListInit>(def->getValueInit("baseInterfaces"));
+  llvm::unique_function<void(Interface)> addBaseInterfaceFn =
+      [&](const Interface &baseInterface) {
+        // Inherit any base interfaces.
+        for (const auto &baseBaseInterface : baseInterface.getBaseInterfaces())
+          addBaseInterfaceFn(baseBaseInterface);
+
+        // Add the base interface.
+        baseInterfaces.push_back(std::make_unique<Interface>(baseInterface));
+      };
+  for (llvm::Init *init : basesInit->getValues())
+    addBaseInterfaceFn(Interface(cast<llvm::DefInit>(init)->getDef()));
 }
 
 // Return the name of this interface.
 StringRef Interface::getName() const {
   return def->getValueAsString("cppInterfaceName");
 }
 
+// Returns this interface's name prefixed with namespaces.
+std::string Interface::getFullyQualifiedName() const {
+  StringRef cppNamespace = getCppNamespace();
+  StringRef name = getName();
+  if (cppNamespace.empty())
+    return name.str();
+  return (cppNamespace + "::" + name).str();
+}
+
 // Return the C++ namespace of this interface.
 StringRef Interface::getCppNamespace() const {
   return def->getValueAsString("cppNamespace");
 }
 
 // Return the methods of this interface.
 ArrayRef<InterfaceMethod> Interface::getMethods() const { return methods; }
 

mlir/lib/TableGen/Operator.cpp

if (auto *traitList = def.getValueAsListInit("traits")) {
     insert = [&](llvm::ListInit *traitList) {
       for (auto *traitInit : *traitList) {
         auto *def = cast<DefInit>(traitInit)->getDef();
         if (def->isSubClassOf("TraitList")) {
           insert(def->getValueAsListInit("traits"));
           continue;
         }
 
+        // Ignore duplicates.
+        if (!traitSet.insert(traitInit).second)
+          continue;
+
+        // If this is an interface with base classes, add the bases to the
+        // trait list.
+        if (def->isSubClassOf("Interface"))
+          insert(def->getValueAsListInit("baseInterfaces"));
+
         // Verify if the trait has all the dependent traits declared before
         // itself.
         verifyTraitValidity(def);
-
-        // Keep traits in the same order while skipping over duplicates.
-        if (traitSet.insert(traitInit).second)
-          traits.push_back(Trait::create(traitInit));
       }
     };
     insert(traitList);
   }
 
   populateTypeInferenceInfo(argumentsAndResultsIndex);
 
   // Handle regions

mlir/test/lib/Dialect/Test/TestInterfaces.td

 //===-- TestInterfaces.td - Test dialect interfaces --------*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TEST_DIALECT_TEST_INTERFACES
 #define MLIR_TEST_DIALECT_TEST_INTERFACES
 
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/SideEffectInterfaceBase.td"
 
-// A type interface used to test the ODS generation of type interfaces.
-def TestTypeInterface : TypeInterface<"TestTypeInterface"> {
+// A set of type interfaces used to test interface inheritance.
+def TestBaseTypeInterfacePrintTypeA : TypeInterface<"TestBaseTypeInterfacePrintTypeA"> {
   let cppNamespace = "::test";
   let methods = [
     InterfaceMethod<"Prints the type name.",
       "void", "printTypeA", (ins "::mlir::Location":$loc), [{
         emitRemark(loc) << $_type << " - TestA";
       }]
-    >,
+    >
+  ];
+}
+def TestBaseTypeInterfacePrintTypeB
+  : TypeInterface<"TestBaseTypeInterfacePrintTypeB", [TestBaseTypeInterfacePrintTypeA]> {
+  let cppNamespace = "::test";
+  let methods = [
     InterfaceMethod<"Prints the type name.",
       "void", "printTypeB", (ins "::mlir::Location":$loc),
       [{}], /*defaultImplementation=*/[{
         emitRemark(loc) << $_type << " - TestB";
       }]
-    >,
+    >
+  ];
+}
+
+// A type interface used to test the ODS generation of type interfaces.
+def TestTypeInterface
+  : TypeInterface<"TestTypeInterface", [TestBaseTypeInterfacePrintTypeB]> {
+  let cppNamespace = "::test";
+  let methods = [
     InterfaceMethod<"Prints the type name.",
       "void", "printTypeC", (ins "::mlir::Location":$loc)
     >,
     // It should be possible to use the interface type name as result type
     // as well as in the implementation.
     InterfaceMethod<"Prints the type name and returns the type as interface.",
       "TestTypeInterface", "printTypeRet", (ins "::mlir::Location":$loc),
       [{}], /*defaultImplementation=*/[{

mlir/test/mlir-tblgen/op-interface.td

 // RUN: mlir-tblgen -gen-op-interface-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
+// RUN: mlir-tblgen -gen-op-interface-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
 // RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck %s --check-prefix=OP_DECL
 // RUN: mlir-tblgen -gen-op-interface-docs -I %S/../../include %s | FileCheck %s --check-prefix=DOCS
 
 include "mlir/IR/OpBase.td"
 
 def ExtraClassOfInterface : OpInterface<"ExtraClassOfInterface"> {
   let extraClassOf = "return $_op->someOtherMethod();";
 }

 // DECL-NEXT:   return (*this).someOtherMethod();
 // DECL-NEXT: }
 
 // DECL: struct ExtraShardDeclsInterfaceTrait
 // DECL:      bool sharedMethodDeclaration() {
 // DECL-NEXT:   return (*static_cast<ConcreteOp *>(this)).someOtherMethod();
 // DECL-NEXT: }
 
+def TestInheritanceBaseInterface : OpInterface<"TestInheritanceBaseInterface"> {
+  let methods = [
+    InterfaceMethod<
+      /*desc=*/[{some function comment}],
+      /*retTy=*/"int",
+      /*methodName=*/"foo",
+      /*args=*/(ins "int":$input)
+    >
+  ];
+}
+def TestInheritanceMiddleBaseInterface
+ : OpInterface<"TestInheritanceMiddleBaseInterface", [TestInheritanceBaseInterface]> {
+  let methods = [
+    InterfaceMethod<
+      /*desc=*/[{some function comment}],
+      /*retTy=*/"int",
+      /*methodName=*/"bar",
+      /*args=*/(ins "int":$input)
+    >
+  ];
+}
+def TestInheritanceZDerivedInterface
+  : OpInterface<"TestInheritanceZDerivedInterface", [TestInheritanceMiddleBaseInterface]>;
+
+// DECL: class TestInheritanceZDerivedInterface
+// DECL: struct Concept {
+// DECL:     const TestInheritanceBaseInterface::Concept *implTestInheritanceBaseInterface = nullptr;
+// DECL:     const TestInheritanceMiddleBaseInterface::Concept *implTestInheritanceMiddleBaseInterface = nullptr;
+
+// DECL:     void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
+// DECL:       implTestInheritanceBaseInterface = interfaceMap.lookup<TestInheritanceBaseInterface>();
+// DECL:       assert(implTestInheritanceBaseInterface && "`TestInheritanceZDerivedInterface` expected its base interface `TestInheritanceBaseInterface` to be registered");
+// DECL:       implTestInheritanceMiddleBaseInterface = interfaceMap.lookup<TestInheritanceMiddleBaseInterface>();
+// DECL:       assert(implTestInheritanceMiddleBaseInterface
+// DECL:     }
+
+// DECL:    //===----------------------------------------------------------------===//
+// DECL:    // Inherited from TestInheritanceBaseInterface
+// DECL:    //===----------------------------------------------------------------===//
+// DECL:    operator TestInheritanceBaseInterface () const {
+// DECL:      return TestInheritanceBaseInterface(*this, getImpl()->implTestInheritanceBaseInterface);
+// DECL:    }
+// DECL:    /// some function comment
+// DECL:    int foo(int input);
+
+// DECL:    //===----------------------------------------------------------------===//
+// DECL:    // Inherited from TestInheritanceMiddleBaseInterface
+// DECL:    //===----------------------------------------------------------------===//
+// DECL:    operator TestInheritanceMiddleBaseInterface () const {
+// DECL:      return TestInheritanceMiddleBaseInterface(*this, getImpl()->implTestInheritanceMiddleBaseInterface);
+// DECL:    }
+// DECL:    /// some function comment
+// DECL:    int bar(int input);
+
+// DEF: int TestInheritanceZDerivedInterface::foo(int input) {
+// DEF-NEXT:    getImpl()->implTestInheritanceBaseInterface->foo(getImpl()->implTestInheritanceBaseInterface, getOperation(), input);
+
+// DEF: int TestInheritanceZDerivedInterface::bar(int input) {
+// DEF-NEXT:   return getImpl()->implTestInheritanceMiddleBaseInterface->bar(getImpl()->implTestInheritanceMiddleBaseInterface, getOperation(), input);
+
 def TestOpInterface : OpInterface<"TestOpInterface"> {
   let description = [{some op interface description}];
 
   let methods = [
     InterfaceMethod<
       /*desc=*/[{some function comment}],
       /*retTy=*/"int",
       /*methodName=*/"foo",

 // DeclareOpInterfaceMethods<TestOpInterface> traits to check that there
 // are not duplicated C++ classes generated.
 def TestDialect : Dialect {
   let name = "test";
 }
 
 def OpInterfaceOp : Op<TestDialect, "op_interface_op", [TestOpInterface]>;
 
+def OpInterfaceInterfacesOp : Op<TestDialect, "op_inherit_interface_op", [TestInheritanceZDerivedInterface]>;
+
 def DeclareMethodsOp : Op<TestDialect, "declare_methods_op",
                           [DeclareOpInterfaceMethods<TestOpInterface>]>;
 
 def DeclareMethodsWithDefaultOp : Op<TestDialect, "declare_methods_op",
       [DeclareOpInterfaceMethods<TestOpInterface, ["default_foo"]>]>;
 
 // DECL-LABEL: TestOpInterfaceInterfaceTraits
 // DECL: class TestOpInterface : public ::mlir::OpInterface<TestOpInterface, detail::TestOpInterfaceInterfaceTraits>

 // OP_DECL-LABEL: class DeclareMethodsOp : public
 // OP_DECL: int foo(int input);
 // OP_DECL-NOT: int default_foo(int input);
 
 // OP_DECL-LABEL: class DeclareMethodsWithDefaultOp : public
 // OP_DECL: int foo(int input);
 // OP_DECL: int default_foo(int input);
 
+// OP_DECL: class OpInterfaceInterfacesOp :
+// OP_DECL-SAME: TestInheritanceBaseInterface::Trait, TestInheritanceMiddleBaseInterface::Trait, TestInheritanceZDerivedInterface::Trait
+
 // DOCS-LABEL: {{^}}## TestOpInterface (`TestOpInterface`)
 // DOCS: some op interface description
 
 // DOCS: {{^}}### Methods:
 
 // DOCS: {{^}}#### `foo`
 // DOCS: some function comment
 
 // DOCS: {{^}}#### `body_foo`
 // DOCS: some function comment
 
 // DOCS: {{^}}#### `default_foo`
 // DOCS: some function comment

mlir/tools/mlir-tblgen/OpInterfacesGen.cpp

 // GEN: Interface definitions
 //===----------------------------------------------------------------------===//
 
 static void emitInterfaceMethodDoc(const InterfaceMethod &method,
                                    raw_ostream &os, StringRef prefix = "") {
   if (std::optional<StringRef> description = method.getDescription())
     tblgen::emitDescriptionComment(*description, os, prefix);
 }
-
-static void emitInterfaceDef(const Interface &interface, StringRef valueType,
-                             raw_ostream &os) {
-  StringRef interfaceName = interface.getName();
-  StringRef cppNamespace = interface.getCppNamespace();
-  cppNamespace.consume_front("::");
-
-  // Insert the method definitions.
-  bool isOpInterface = isa<OpInterface>(interface);
+static void emitInterfaceDefMethods(StringRef interfaceQualName,
+                                    const Interface &interface,
+                                    StringRef valueType, const Twine &implValue,
+                                    raw_ostream &os, bool isOpInterface) {
   for (auto &method : interface.getMethods()) {
     emitInterfaceMethodDoc(method, os);
     emitCPPType(method.getReturnType(), os);
-    if (!cppNamespace.empty())
-      os << cppNamespace << "::";
-    os << interfaceName << "::";
+    os << interfaceQualName << "::";
     emitMethodNameAndArgs(method, os, valueType, /*addThisArg=*/false,
                           /*addConst=*/!isOpInterface);
 
     // Forward to the method on the concrete operation type.
-    os << " {\n      return getImpl()->" << method.getName() << '(';
+    os << " {\n      return " << implValue << "->" << method.getName() << '(';
     if (!method.isStatic()) {
-      os << "getImpl(), ";
+      os << implValue << ", ";
       os << (isOpInterface ? "getOperation()" : "*this");
       os << (method.arg_empty() ? "" : ", ");
     }
     llvm::interleaveComma(
         method.getArguments(), os,
         [&](const InterfaceMethod::Argument &arg) { os << arg.name; });
     os << ");\n  }\n";
   }
 }
 
+static void emitInterfaceDef(const Interface &interface, StringRef valueType,
+                             raw_ostream &os) {
+  std::string interfaceQualNameStr = interface.getFullyQualifiedName();
+  StringRef interfaceQualName = interfaceQualNameStr;
+  interfaceQualName.consume_front("::");
+
+  // Insert the method definitions.
+  bool isOpInterface = isa<OpInterface>(interface);
+  emitInterfaceDefMethods(interfaceQualName, interface, valueType, "getImpl()",
+                          os, isOpInterface);
+
+  // Insert the method definitions for base classes.
+  for (auto &base : interface.getBaseInterfaces()) {
+    emitInterfaceDefMethods(interfaceQualName, base, valueType,
+                            "getImpl()->impl" + base.getName(), os,
+                            isOpInterface);
+  }
+}
+
 bool InterfaceGenerator::emitInterfaceDefs() {
   llvm::emitSourceFileHeader("Interface Definitions", os);
 
   for (const auto *def : defs)
     emitInterfaceDef(Interface(def), valueType, os);
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // GEN: Interface declarations
 //===----------------------------------------------------------------------===//
 
 void InterfaceGenerator::emitConceptDecl(const Interface &interface) {
   os << "  struct Concept {\n";
 
   // Insert each of the pure virtual concept methods.
+  os << "    /// The methods defined by the interface.\n";
   for (auto &method : interface.getMethods()) {
     os << "    ";
     emitCPPType(method.getReturnType(), os);
     os << "(*" << method.getName() << ")(";
     if (!method.isStatic()) {
       os << "const Concept *impl, ";
       emitCPPType(valueType, os) << (method.arg_empty() ? "" : ", ");
     }
     llvm::interleaveComma(
         method.getArguments(), os,
         [&](const InterfaceMethod::Argument &arg) { os << arg.type; });
     os << ");\n";
   }
+
+  // Insert a field containing a concept for each of the base interfaces.
+  auto baseInterfaces = interface.getBaseInterfaces();
+  if (!baseInterfaces.empty()) {
+    os << "    /// The base classes of this interface.\n";
+    for (const auto &base : interface.getBaseInterfaces()) {
+      os << "    const " << base.getFullyQualifiedName() << "::Concept *impl"
+         << base.getName() << " = nullptr;\n";
+    }
+
+    // Define an "initialize" method that allows for the initialization of the
+    // base class concepts.
+    os << "\n    void initializeInterfaceConcept(::mlir::detail::InterfaceMap "
+          "&interfaceMap) {\n";
+    std::string interfaceQualName = interface.getFullyQualifiedName();
+    for (const auto &base : interface.getBaseInterfaces()) {
+      StringRef baseName = base.getName();
+      std::string baseQualName = base.getFullyQualifiedName();
+      os << "      impl" << baseName << " = interfaceMap.lookup<"
+         << baseQualName << ">();\n"
+         << "      assert(impl" << baseName << " && \"`" << interfaceQualName
+         << "` expected its base interface `" << baseQualName
+         << "` to be registered\");\n";
+    }
+    os << "    }\n";
+  }
+
   os << "  };\n";
 }
 
 void InterfaceGenerator::emitModelDecl(const Interface &interface) {
   // Emit the basic model and the fallback model.
   for (const char *modelClass : {"Model", "FallbackModel"}) {
     os << "  template<typename " << valueTemplate << ">\n";
     os << "  class " << modelClass << " : public Concept {\n  public:\n";
-    os << "    using Interface = " << interface.getCppNamespace()
-       << (interface.getCppNamespace().empty() ? "" : "::")
-       << interface.getName() << ";\n";
+    os << "    using Interface = " << interface.getFullyQualifiedName()
+       << ";\n";
     os << "    " << modelClass << "() : Concept{";
     llvm::interleaveComma(
         interface.getMethods(), os,
         [&](const InterfaceMethod &method) { os << method.getName(); });
     os << "} {}\n\n";
 
     // Insert each of the virtual method overrides.
     for (auto &method : interface.getMethods()) {
void InterfaceGenerator::emitTraitDecl(const Interface &interface,
   if (auto extraTraitDecls = interface.getExtraTraitClassDeclaration())
     os << tblgen::tgfmt(*extraTraitDecls, &traitMethodFmt) << "\n";
   if (auto extraTraitDecls = interface.getExtraSharedClassDeclaration())
     os << tblgen::tgfmt(*extraTraitDecls, &traitMethodFmt) << "\n";
 
   os << "  };\n";
 }
 
+static void emitInterfaceDeclMethods(const Interface &interface,
+                                     raw_ostream &os, StringRef valueType,
+                                     bool isOpInterface,
+                                     tblgen::FmtContext &extraDeclsFmt) {
+  for (auto &method : interface.getMethods()) {
+    emitInterfaceMethodDoc(method, os, "  ");
+    emitCPPType(method.getReturnType(), os << "  ");
+    emitMethodNameAndArgs(method, os, valueType, /*addThisArg=*/false,
+                          /*addConst=*/!isOpInterface);
+    os << ";\n";
+  }
+
+  // Emit any extra declarations.
+  if (std::optional<StringRef> extraDecls =
+          interface.getExtraClassDeclaration())
+    os << extraDecls->rtrim() << "\n";
+  if (std::optional<StringRef> extraDecls =
+          interface.getExtraSharedClassDeclaration())
+    os << tblgen::tgfmt(extraDecls->rtrim(), &extraDeclsFmt) << "\n";
+}
+
 void InterfaceGenerator::emitInterfaceDecl(const Interface &interface) {
   llvm::SmallVector<StringRef, 2> namespaces;
   llvm::SplitString(interface.getCppNamespace(), namespaces, "::");
   for (StringRef ns : namespaces)
     os << "namespace " << ns << " {\n";
 
   StringRef interfaceName = interface.getName();
   auto interfaceTraitsName = (interfaceName + "InterfaceTraits").str();
void InterfaceGenerator::emitInterfaceDecl(const Interface &interface) {
 
   // Emit a utility wrapper trait class.
   os << llvm::formatv("  template <typename {1}>\n"
                       "  struct Trait : public detail::{0}Trait<{1}> {{};\n",
                       interfaceName, valueTemplate);
 
   // Insert the method declarations.
   bool isOpInterface = isa<OpInterface>(interface);
-  for (auto &method : interface.getMethods()) {
-    emitInterfaceMethodDoc(method, os, "  ");
-    emitCPPType(method.getReturnType(), os << "  ");
-    emitMethodNameAndArgs(method, os, valueType, /*addThisArg=*/false,
-                          /*addConst=*/!isOpInterface);
-    os << ";\n";
-  }
+  emitInterfaceDeclMethods(interface, os, valueType, isOpInterface,
+                           extraDeclsFmt);
 
-  // Emit any extra declarations.
-  if (std::optional<StringRef> extraDecls =
-          interface.getExtraClassDeclaration())
-    os << *extraDecls << "\n";
-  if (std::optional<StringRef> extraDecls =
-          interface.getExtraSharedClassDeclaration())
-    os << tblgen::tgfmt(*extraDecls, &extraDeclsFmt);
+  // Insert the method declarations for base classes.
+  for (auto &base : interface.getBaseInterfaces()) {
+    std::string baseQualName = base.getFullyQualifiedName();
+    os << "  //"
+          "===---------------------------------------------------------------"
+          "-===//\n"
+       << "  // Inherited from " << baseQualName << "\n"
+       << "  //"
+          "===---------------------------------------------------------------"
+          "-===//\n\n";
+
+    // Allow implicit conversion to the base interface.
+    os << "  operator " << baseQualName << " () const {\n"
+       << "    return " << baseQualName << "(*this, getImpl()->impl"
+       << base.getName() << ");\n"
+       << "  }\n\n";
+
+    // Inherit the base interface's methods.
+    emitInterfaceDeclMethods(base, os, valueType, isOpInterface, extraDeclsFmt);
+  }
 
   // Emit classof code if necessary.
   if (std::optional<StringRef> extraClassOf = interface.getExtraClassOf()) {
     auto extraClassOfFmt = tblgen::FmtContext();
     extraClassOfFmt.addSubst(substVar, "base");
     os << "  static bool classof(" << valueType << " base) {\n"
        << "    if (!getInterfaceFor(base))\n"
           "      return false;\n"

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

os << "  class Concept {\n"
      << "  };\n";
 }
 
 static void emitModelDecl(const Availability &availability, raw_ostream &os) {
   for (const char *modelClass : {"Model", "FallbackModel"}) {
     os << "  template<typename ConcreteOp>\n";
     os << "  class " << modelClass << " : public Concept {\n"
        << "  public:\n"
+       << "    using Interface = " << availability.getInterfaceClassName()
+       << ";\n"
        << "    " << availability.getQueryFnRetType() << " "
        << availability.getQueryFnName()
        << "(const Concept *impl, Operation *tblgen_opaque_op) const final {\n"
        << "      auto op = llvm::cast<ConcreteOp>(tblgen_opaque_op);\n"
        << "      (void)op;\n"
        // Forward to the method on the concrete operation type.
        << "      return op." << availability.getQueryFnName() << "();\n"
        << "    }\n"
        << "  };\n";
   }
   os << "  template<typename ConcreteModel, typename ConcreteOp>\n";
   os << "  class ExternalModel : public FallbackModel<ConcreteOp> {};\n";
 }
 
 static void emitInterfaceDecl(const Availability &availability,
                               raw_ostream &os) {
   StringRef interfaceName = availability.getInterfaceClassName();
   std::string interfaceTraitsName =
       std::string(formatv("{0}Traits", interfaceName));
 
   StringRef cppNamespace = availability.getInterfaceClassNamespace();
   NamespaceEmitter nsEmitter(os, cppNamespace);
+  os << "class " << interfaceName << ";\n\n";
 
   // Emit the traits struct containing the concept and model declarations.
   os << "namespace detail {\n"
      << "struct " << interfaceTraitsName << " {\n";
   emitConceptDecl(availability, os);
   os << '\n';
   emitModelDecl(availability, os);
   os << "};\n} // namespace detail\n\n";