[mlir] Extend the promise interface mechanism

[fmorac]

Summary

This patch pairs a promised interface with the object (Op/Attr/Type/Dialect) requesting the promise, ie:

declarePromisedInterface<MyAttr, MyInterface>();

Allowing to make fine grained promises. It also adds a mechanism to query if Op/Attr/Type has an specific promise returning true if the promise is there or if an implementation has been added. Finally it adds a couple of Attr|TypeConstraints that can be used in ODS to query if the promise or an implementation is there.

This patch tries to solve 2 issues:

1. Different entities cannot use the same promise.

declarePromisedInterface<MyInterface>();
// Resolves a promise.
MyAttr1::attachInterface<MyInterface>(ctx);
// Doesn't resolves a promise, as the previous attachment removed the promise.
MyAttr2::attachInterface<MyInterface>(ctx);

2. Is not possible to query if a promise has been declared.

[fmorac]

Ping for review.

mlir/include/mlir/IR/Attributes.h

public:
   const void *getAsOpaquePointer() const { return impl; }
   /// Construct an attribute from the opaque pointer representation.
   static Attribute getFromOpaquePointer(const void *ptr) {
     return Attribute(reinterpret_cast<const ImplType *>(ptr));
   }
 
   friend ::llvm::hash_code hash_value(Attribute arg);
 
+  /// Returns true if `InterfaceT` has been promised by the dialect or
+  /// implemented.
+  template <typename InterfaceT>
+  bool hasPromiseOrImplementsInterface() {
+    return dialect_extension_detail::hasPromisedInterface(
+               getDialect(), getTypeID(), InterfaceT::getInterfaceID()) ||
+           mlir::isa<InterfaceT>(*this);
+  }
+
   /// Returns true if the type was registered with a particular trait.
   template <template <typename T> class Trait>
   bool hasTrait() {
     return getAbstractAttribute().hasTrait<Trait>();
   }
 
   /// Return the abstract descriptor for this attribute.
   const AbstractTy &getAbstractAttribute() const {

 
 private:
   /// Returns the impl interface instance for the given type.
   static typename InterfaceBase::Concept *getInterfaceFor(Attribute attr) {
 #ifndef NDEBUG
     // Check that the current interface isn't an unresolved promise for the
     // given attribute.
     dialect_extension_detail::handleUseOfUndefinedPromisedInterface(
-        attr.getDialect(), ConcreteType::getInterfaceID(),
+        attr.getDialect(), attr.getTypeID(), ConcreteType::getInterfaceID(),
         llvm::getTypeName<ConcreteType>());
 #endif
 
     return attr.getAbstractAttribute().getInterface<ConcreteType>();
   }
 
   /// Allow access to 'getInterfaceFor'.
   friend InterfaceBase;

mlir/include/mlir/IR/Dialect.h

public:
   //===--------------------------------------------------------------------===//
   // Interfaces
   //===--------------------------------------------------------------------===//
 
   /// Lookup an interface for the given ID if one is registered, otherwise
   /// nullptr.
   DialectInterface *getRegisteredInterface(TypeID interfaceID) {
 #ifndef NDEBUG
-    handleUseOfUndefinedPromisedInterface(interfaceID);
+    handleUseOfUndefinedPromisedInterface(getTypeID(), interfaceID);
 #endif
 
     auto it = registeredInterfaces.find(interfaceID);
     return it != registeredInterfaces.end() ? it->getSecond().get() : nullptr;
   }
   template <typename InterfaceT>
   InterfaceT *getRegisteredInterface() {
 #ifndef NDEBUG
-    handleUseOfUndefinedPromisedInterface(InterfaceT::getInterfaceID(),
+    handleUseOfUndefinedPromisedInterface(getTypeID(),
+                                          InterfaceT::getInterfaceID(),
                                           llvm::getTypeName<InterfaceT>());
 #endif
 
     return static_cast<InterfaceT *>(
         getRegisteredInterface(InterfaceT::getInterfaceID()));
   }
 
   /// Lookup an op interface for the given ID if one is registered, otherwise
InterfaceT &addInterface(Args &&...args) {
     addInterface(std::unique_ptr<DialectInterface>(interface));
     return *interface;
   }
 
   /// Declare that the given interface will be implemented, but has a delayed
   /// registration. The promised interface type can be an interface of any type
   /// not just a dialect interface, i.e. it may also be an
   /// AttributeInterface/OpInterface/TypeInterface/etc.
-  template <typename InterfaceT>
+  template <typename ConcreteT, typename InterfaceT>
   void declarePromisedInterface() {
-    unresolvedPromisedInterfaces.insert(InterfaceT::getInterfaceID());
+    unresolvedPromisedInterfaces.insert(
+        {TypeID::get<ConcreteT>(), InterfaceT::getInterfaceID()});
   }
 
   /// Checks if the given interface, which is attempting to be used, is a
   /// promised interface of this dialect that has yet to be implemented. If so,
   /// emits a fatal error. `interfaceName` is an optional string that contains a
   /// more user readable name for the interface (such as the class name).
-  void handleUseOfUndefinedPromisedInterface(TypeID interfaceID,
+  void handleUseOfUndefinedPromisedInterface(TypeID interfaceRequestorID,
+                                             TypeID interfaceID,
                                              StringRef interfaceName = "") {
-    if (unresolvedPromisedInterfaces.count(interfaceID)) {
+    if (unresolvedPromisedInterfaces.count(
+            {interfaceRequestorID, interfaceID})) {
       llvm::report_fatal_error(
           "checking for an interface (`" + interfaceName +
           "`) that was promised by dialect '" + getNamespace() +
           "' but never implemented. This is generally an indication "
           "that the dialect extension implementing the interface was never "
           "registered.");
     }
   }
+
   /// Checks if the given interface, which is attempting to be attached to a
   /// construct owned by this dialect, is a promised interface of this dialect
   /// that has yet to be implemented. If so, it resolves the interface promise.
-  void handleAdditionOfUndefinedPromisedInterface(TypeID interfaceID) {
-    unresolvedPromisedInterfaces.erase(interfaceID);
+  void handleAdditionOfUndefinedPromisedInterface(TypeID interfaceRequestorID,
+                                                  TypeID interfaceID) {
+    unresolvedPromisedInterfaces.erase({interfaceRequestorID, interfaceID});
+  }
+
+  /// Checks if a promise has been made for the interface/requestor pair.
+  bool hasPromisedInterface(TypeID interfaceRequestorID,
+                            TypeID interfaceID) const {
+    return unresolvedPromisedInterfaces.count(
+        {interfaceRequestorID, interfaceID});
+  }
+
+  /// Checks if a promise has been made for the interface/requestor pair.
+  template <typename ConcreteT, typename InterfaceT>
+  bool hasPromisedInterface() const {
+    return hasPromisedInterface(TypeID::get<ConcreteT>(),
+                                InterfaceT::getInterfaceID());
   }
 
 protected:
   /// The constructor takes a unique namespace for this dialect as well as the
   /// context to bind to.
   /// Note: The namespace must not contain '.' characters.
   /// Note: All operations belonging to this dialect must have names starting
   ///       with the namespace followed by '.'.
private:
   bool unknownTypesAllowed = false;
 
   /// A collection of registered dialect interfaces.
   DenseMap<TypeID, std::unique_ptr<DialectInterface>> registeredInterfaces;
 
   /// A set of interfaces that the dialect (or its constructs, i.e.
   /// Attributes/Operations/Types/etc.) has promised to implement, but has yet
   /// to provide an implementation for.
-  DenseSet<TypeID> unresolvedPromisedInterfaces;
+  DenseSet<std::pair<TypeID, TypeID>> unresolvedPromisedInterfaces;
 
   friend class DialectRegistry;
   friend void registerDialect();
   friend class MLIRContext;
 };
 
 } // namespace mlir
 

mlir/include/mlir/IR/DialectRegistry.h

protected:
   }
 };
 
 namespace dialect_extension_detail {
 
 /// Checks if the given interface, which is attempting to be used, is a
 /// promised interface of this dialect that has yet to be implemented. If so,
 /// emits a fatal error.
-void handleUseOfUndefinedPromisedInterface(Dialect &dialect, TypeID interfaceID,
+void handleUseOfUndefinedPromisedInterface(Dialect &dialect,
+                                           TypeID interfaceRequestorID,
+                                           TypeID interfaceID,
                                            StringRef interfaceName);
 
 /// Checks if the given interface, which is attempting to be attached, is a
 /// promised interface of this dialect that has yet to be implemented. If so,
 /// the promised interface is marked as resolved.
 void handleAdditionOfUndefinedPromisedInterface(Dialect &dialect,
+                                                TypeID interfaceRequestorID,
                                                 TypeID interfaceID);
 
+/// Checks if a promise has been made for the interface/requestor pair.
+bool hasPromisedInterface(Dialect &dialect, TypeID interfaceRequestorID,
+                          TypeID interfaceID);
+
+/// Checks if a promise has been made for the interface/requestor pair.
+template <typename ConcreteT, typename InterfaceT>
+bool hasPromisedInterface(Dialect &dialect) {
+  return hasPromisedInterface(dialect, TypeID::get<ConcreteT>(),
+                              InterfaceT::getInterfaceID());
+}
+
 } // namespace dialect_extension_detail
 
 //===----------------------------------------------------------------------===//
 // DialectRegistry
 //===----------------------------------------------------------------------===//
 
 /// The DialectRegistry maps a dialect namespace to a constructor for the
 /// matching dialect. This allows for decoupling the list of dialects

mlir/include/mlir/IR/OpBase.td

 }
 
 // The results of an op.
 class Results<dag rets> {
   dag results = rets;
 }
 
 //===----------------------------------------------------------------------===//
+// Common promised interface constraints
+//===----------------------------------------------------------------------===//
+
+// This constrait represents a promise or an implementation of an attr interface.
+class PromisedAttrInterface<AttrInterface interface> : AttrConstraint<
+  CPred<"$_self.hasPromiseOrImplementsInterface<" #
+    !if(!empty(interface.cppNamespace),
+        "",
+        interface.cppNamespace # "::") # interface.cppInterfaceName #">()">,
+  "promising or implementing the `" # interface.cppInterfaceName # "` attr interface">;
+
+// This predicate checks if the type promises or implementats a type interface.
+class HasPromiseOrImplementsTypeInterface<TypeInterface interface> :
+  CPred<"$_self.hasPromiseOrImplementsInterface<" #
+    !if(!empty(interface.cppNamespace),
+        "",
+        interface.cppNamespace # "::") # interface.cppInterfaceName #">()">;
+
+// This constrait represents a promise or an implementation of a type interface.
+class PromisedTypeInterface<TypeInterface interface> : TypeConstraint<
+  HasPromiseOrImplementsTypeInterface<interface>,
+  "promising or implementing the `" # interface.cppInterfaceName # "` type interface">;
+
+//===----------------------------------------------------------------------===//
 // Common op type constraints
 //===----------------------------------------------------------------------===//
 
 // These traits are for verifying properties of an op that require knowledge of
 // multiple arguments or results. For verifying properties of a single argument
 // or result, prefer operand type constraints.
 
 // These traits often require including "mlir/IR/TypeUtilities.h".

mlir/include/mlir/IR/OpDefinition.h

protected:
   static typename InterfaceBase::Concept *getInterfaceFor(Operation *op) {
     OperationName name = op->getName();
 
 #ifndef NDEBUG
     // Check that the current interface isn't an unresolved promise for the
     // given operation.
     if (Dialect *dialect = name.getDialect()) {
       dialect_extension_detail::handleUseOfUndefinedPromisedInterface(
-          *dialect, ConcreteType::getInterfaceID(),
+          *dialect, name.getTypeID(), ConcreteType::getInterfaceID(),
           llvm::getTypeName<ConcreteType>());
     }
 #endif
 
     // Access the raw interface from the operation info.
     if (std::optional<RegisteredOperationName> rInfo =
             name.getRegisteredInfo()) {
       if (auto *opIface = rInfo->getInterface<ConcreteType>())

mlir/include/mlir/IR/Operation.h

public:
   ///
   /// If folding was successful, this function returns "success".
   /// * If this operation was modified in-place (but not folded away),
   ///   `results` is empty.
   /// * Otherwise, `results` is filled with the folded results.
   /// If folding was unsuccessful, this function returns "failure".
   LogicalResult fold(SmallVectorImpl<OpFoldResult> &results);
 
+  /// Returns true if `InterfaceT` has been promised by the dialect or
+  /// implemented.
+  template <typename InterfaceT>
+  bool hasPromiseOrImplementsInterface() const {
+    return name.hasPromiseOrImplementsInterface<InterfaceT>();
+  }
+
   /// Returns true if the operation was registered with a particular trait, e.g.
   /// hasTrait<OperandsAreSignlessIntegerLike>().
   template <template <typename T> class Trait>
   bool hasTrait() {
     return name.hasTrait<Trait>();
   }
 
   /// Returns true if the operation *might* have the provided trait. This

mlir/include/mlir/IR/OperationSupport.h

public:
   }
 
   /// Attach the given models as implementations of the corresponding
   /// interfaces for the concrete operation.
   template <typename... Models>
   void attachInterface() {
     // Handle the case where the models resolve a promised interface.
     (dialect_extension_detail::handleAdditionOfUndefinedPromisedInterface(
-         *getDialect(), Models::Interface::getInterfaceID()),
+         *getDialect(), getTypeID(), Models::Interface::getInterfaceID()),
      ...);
 
     getImpl()->getInterfaceMap().insertModels<Models...>();
   }
 
+  /// Returns true if `InterfaceT` has been promised by the dialect or
+  /// implemented.
+  template <typename InterfaceT>
+  bool hasPromiseOrImplementsInterface() const {
+    return dialect_extension_detail::hasPromisedInterface(
+               getDialect(), getTypeID(), InterfaceT::getInterfaceID()) ||
+           hasInterface<InterfaceT>();
+  }
+
   /// 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 {
     return getImpl()->getInterfaceMap().contains(interfaceID);
   }

mlir/include/mlir/IR/StorageUniquerSupport.h

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.");
 
     // Handle the case where the models resolve a promised interface.
     (dialect_extension_detail::handleAdditionOfUndefinedPromisedInterface(
-         abstract->getDialect(), IfaceModels::Interface::getInterfaceID()),
+         abstract->getDialect(), abstract->getTypeID(),
+         IfaceModels::Interface::getInterfaceID()),
      ...);
 
     (checkInterfaceTarget<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

mlir/include/mlir/IR/Types.h

public:
   /// Methods for supporting PointerLikeTypeTraits.
   const void *getAsOpaquePointer() const {
     return static_cast<const void *>(impl);
   }
   static Type getFromOpaquePointer(const void *pointer) {
     return Type(reinterpret_cast<ImplType *>(const_cast<void *>(pointer)));
   }
 
+  /// Returns true if `InterfaceT` has been promised by the dialect or
+  /// implemented.
+  template <typename InterfaceT>
+  bool hasPromiseOrImplementsInterface() {
+    return dialect_extension_detail::hasPromisedInterface(
+               getDialect(), getTypeID(), InterfaceT::getInterfaceID()) ||
+           mlir::isa<InterfaceT>(*this);
+  }
+
   /// Returns true if the type was registered with a particular trait.
   template <template <typename T> class Trait>
   bool hasTrait() {
     return getAbstractType().hasTrait<Trait>();
   }
 
   /// Return the abstract type descriptor for this type.
   const AbstractTy &getAbstractType() const { return impl->getAbstractType(); }

 
 private:
   /// Returns the impl interface instance for the given type.
   static typename InterfaceBase::Concept *getInterfaceFor(Type type) {
 #ifndef NDEBUG
     // Check that the current interface isn't an unresolved promise for the
     // given type.
     dialect_extension_detail::handleUseOfUndefinedPromisedInterface(
-        type.getDialect(), ConcreteType::getInterfaceID(),
+        type.getDialect(), type.getTypeID(), ConcreteType::getInterfaceID(),
         llvm::getTypeName<ConcreteType>());
 #endif
 
     return type.getAbstractType().getInterface<ConcreteType>();
   }
 
   /// Allow access to 'getInterfaceFor'.
   friend InterfaceBase;

mlir/lib/Dialect/Func/IR/FuncOps.cpp

 // FuncDialect
 //===----------------------------------------------------------------------===//
 
 void FuncDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Func/IR/FuncOps.cpp.inc"
       >();
-  declarePromisedInterface<DialectInlinerInterface>();
+  declarePromisedInterface<FuncDialect, DialectInlinerInterface>();
 }
 
 /// Materialize a single constant operation from a given attribute value with
 /// the desired resultant type.
 Operation *FuncDialect::materializeConstant(OpBuilder &builder, Attribute value,
                                             Type type, Location loc) {
   if (ConstantOp::isBuildableWith(value, type))
     return builder.create<ConstantOp>(loc, type,

mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp

#include "mlir/Dialect/LLVMIR/NVVMOps.cpp.inc"
   addAttributes<
 #define GET_ATTRDEF_LIST
 #include "mlir/Dialect/LLVMIR/NVVMOpsAttributes.cpp.inc"
       >();
 
   // Support unknown operations because not all NVVM operations are
   // registered.
   allowUnknownOperations();
-  declarePromisedInterface<ConvertToLLVMPatternInterface>();
-  declarePromisedInterface<gpu::TargetAttrInterface>();
+  declarePromisedInterface<NVVMDialect, ConvertToLLVMPatternInterface>();
+  declarePromisedInterface<NVVMTargetAttr, gpu::TargetAttrInterface>();
 }
 
 LogicalResult NVVMDialect::verifyOperationAttribute(Operation *op,
                                                     NamedAttribute attr) {
   StringAttr attrName = attr.getName();
   // Kernel function attribute should be attached to functions.
   if (attrName == NVVMDialect::getKernelFuncAttrName()) {
     if (!isa<LLVM::LLVMFuncOp>(op)) {

mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp

#include "mlir/Dialect/LLVMIR/ROCDLOps.cpp.inc"
 
   addAttributes<
 #define GET_ATTRDEF_LIST
 #include "mlir/Dialect/LLVMIR/ROCDLOpsAttributes.cpp.inc"
       >();
 
   // Support unknown operations because not all ROCDL operations are registered.
   allowUnknownOperations();
-  declarePromisedInterface<gpu::TargetAttrInterface>();
+  declarePromisedInterface<ROCDLTargetAttr, gpu::TargetAttrInterface>();
 }
 
 LogicalResult ROCDLDialect::verifyOperationAttribute(Operation *op,
                                                      NamedAttribute attr) {
   // Kernel function attribute should be attached to functions.
   if (attr.getName() == ROCDLDialect::getKernelFuncAttrName()) {
     if (!isa<LLVM::LLVMFuncOp>(op)) {
       return op->emitError() << "'" << ROCDLDialect::getKernelFuncAttrName()

mlir/lib/IR/Dialect.cpp

 bool Dialect::isValidNamespace(StringRef str) {
   llvm::Regex dialectNameRegex("^[a-zA-Z_][a-zA-Z_0-9\\$]*$");
   return dialectNameRegex.match(str);
 }
 
 /// Register a set of dialect interfaces with this dialect instance.
 void Dialect::addInterface(std::unique_ptr<DialectInterface> interface) {
   // Handle the case where the models resolve a promised interface.
-  handleAdditionOfUndefinedPromisedInterface(interface->getID());
+  handleAdditionOfUndefinedPromisedInterface(getTypeID(), interface->getID());
 
   auto it = registeredInterfaces.try_emplace(interface->getID(),
                                              std::move(interface));
   (void)it;
   LLVM_DEBUG({
     if (!it.second) {
       llvm::dbgs() << "[" DEBUG_TYPE
                       "] repeated interface registration for dialect "

 MLIRContext *DialectInterface::getContext() const {
   return dialect->getContext();
 }
 
 DialectInterfaceCollectionBase::DialectInterfaceCollectionBase(
     MLIRContext *ctx, TypeID interfaceKind, StringRef interfaceName) {
   for (auto *dialect : ctx->getLoadedDialects()) {
 #ifndef NDEBUG
-  dialect->handleUseOfUndefinedPromisedInterface(interfaceKind, interfaceName);
+    dialect->handleUseOfUndefinedPromisedInterface(
+        dialect->getTypeID(), interfaceKind, interfaceName);
 #endif
     if (auto *interface = dialect->getRegisteredInterface(interfaceKind)) {
       interfaces.insert(interface);
       orderedInterfaces.push_back(interface);
     }
   }
 }
 
 DialectInterfaceCollectionBase::~DialectInterfaceCollectionBase() = default;
 
 /// Get the interface for the dialect of given operation, or null if one
 /// is not registered.
 const DialectInterface *
 DialectInterfaceCollectionBase::getInterfaceFor(Operation *op) const {
   return getInterfaceFor(op->getDialect());
 }
 
 //===----------------------------------------------------------------------===//
 // DialectExtension
 //===----------------------------------------------------------------------===//
 
 DialectExtensionBase::~DialectExtensionBase() = default;
 
 void dialect_extension_detail::handleUseOfUndefinedPromisedInterface(
-    Dialect &dialect, TypeID interfaceID, StringRef interfaceName) {
-  dialect.handleUseOfUndefinedPromisedInterface(interfaceID, interfaceName);
+    Dialect &dialect, TypeID interfaceRequestorID, TypeID interfaceID,
+    StringRef interfaceName) {
+  dialect.handleUseOfUndefinedPromisedInterface(interfaceRequestorID,
+                                                interfaceID, interfaceName);
 }
 
 void dialect_extension_detail::handleAdditionOfUndefinedPromisedInterface(
-    Dialect &dialect, TypeID interfaceID) {
-  dialect.handleAdditionOfUndefinedPromisedInterface(interfaceID);
+    Dialect &dialect, TypeID interfaceRequestorID, TypeID interfaceID) {
+  dialect.handleAdditionOfUndefinedPromisedInterface(interfaceRequestorID,
+                                                     interfaceID);
+}
+
+bool dialect_extension_detail::hasPromisedInterface(Dialect &dialect,
+                                                    TypeID interfaceRequestorID,
+                                                    TypeID interfaceID) {
+  return dialect.hasPromisedInterface(interfaceRequestorID, interfaceID);
 }
 
 //===----------------------------------------------------------------------===//
 // DialectRegistry
 //===----------------------------------------------------------------------===//
 
 DialectRegistry::DialectRegistry() { insert<BuiltinDialect>(); }
 

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

let arguments = (ins
       ConfinedAttr<DenseF64ArrayAttr,
                    [DenseArrayNonNegative<DenseF64ArrayAttr>]>:$f64attr,
       ConfinedAttr<DenseI16ArrayAttr,
                    [DenseArrayNonNegative<DenseI16ArrayAttr>]>:$emptyattr
   );
 }
 
 //===----------------------------------------------------------------------===//
+// Test Promised Interfaces Constraints
+//===----------------------------------------------------------------------===//
+
+def PromisedInterfacesOp : TEST_Op<"promised_interfaces"> {
+  let arguments = (ins
+      ConfinedAttr<AnyAttr,
+          [PromisedAttrInterface<TestExternalAttrInterface>]>:$promisedAttr,
+      ConfinedType<AnyType,
+          [HasPromiseOrImplementsTypeInterface<TestExternalTypeInterface>]
+        >:$promisedType
+  );
+}
+
+//===----------------------------------------------------------------------===//
 // Test Enum Attributes
 //===----------------------------------------------------------------------===//
 
 // Define the enum attribute.
 def TestEnumAttr : EnumAttr<Test_Dialect, TestEnum, "enum">;
 
 // Define an op that contains the enum attribute.
 def OpWithEnum : TEST_Op<"op_with_enum"> {

mlir/unittests/IR/InterfaceAttachmentTest.cpp

TEST(InterfaceAttachment, OperationDelayedContextAppend) {
   context.appendDialectRegistry(registry);
 
   EXPECT_TRUE(isa<TestExternalOpInterface>(module->getOperation()));
   EXPECT_TRUE(isa<TestExternalOpInterface>(opJ.getOperation()));
   EXPECT_TRUE(isa<TestExternalOpInterface>(opH.getOperation()));
   EXPECT_FALSE(isa<TestExternalOpInterface>(opI.getOperation()));
 }
 
+TEST(InterfaceAttachmentTest, PromisedInterfaces) {
+  // Attribute interfaces use the exact same mechanism as types, so just check
+  // that the promise mechanism works for attributes.
+  MLIRContext context;
+  auto testDialect = context.getOrLoadDialect<test::TestDialect>();
+  auto attr = test::SimpleAAttr::get(&context);
+
+  // `SimpleAAttr` doesn't implement nor promises the
+  // `TestExternalAttrInterface` interface.
+  EXPECT_FALSE(isa<TestExternalAttrInterface>(attr));
+  EXPECT_FALSE(
+      attr.hasPromiseOrImplementsInterface<TestExternalAttrInterface>());
+
+  // Add a promise `TestExternalAttrInterface`.
+  testDialect->declarePromisedInterface<test::SimpleAAttr,
+                                        TestExternalAttrInterface>();
+  EXPECT_TRUE(
+      attr.hasPromiseOrImplementsInterface<TestExternalAttrInterface>());
+
+  // Attach the interface.
+  test::SimpleAAttr::attachInterface<TestExternalAttrInterface>(context);
+  EXPECT_TRUE(isa<TestExternalAttrInterface>(attr));
+  EXPECT_TRUE(
+      attr.hasPromiseOrImplementsInterface<TestExternalAttrInterface>());
+}
+
 } // namespace