[mlir][OpInterfaces] Add support for generating a DialectInterface fallback for OpInterfaces

[rriddle]

Summary

This allows for a dialect to provide an implementation of an OpInterface for select unregistered operations. The fallback interface is generated when an OpInterface set generateDialectFallback to 1. The fallback interface requires the implementation of the same hooks as the op-specific model, along with an additional hook: bool isOpSupported(OperationName op) const that allows for filtering which unregistered operations are supported. The use of this fallback is transparent to users of the interface.

Depends On D92895

[jpienaar]

Nice, first scan, may be a bad base change here as it feels like some unrelated changes.

mlir/docs/Interfaces.md

215

"filters" makes me think exclude. Could we use a different word here?

233

Would this be default false if not overridden?

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterface.td

852

Related change?

mlir/include/mlir/IR/OpDefinition.h

1765

s/does have/has/ ?

1771

dialect interface?

mlir/include/mlir/IR/RegionKindInterface.td

42

Related?

[jpienaar]

I know there was another prototype in this region, does that subsume this?

[mehdi_amini]

In D92898#2520601, @jpienaar wrote:

I know there was another prototype in this region, does that subsume this?

I have this: https://reviews.llvm.org/D93085 but River had a suggestion about the implementation and I didn't come to finish trying this alternative.

[rriddle]

In D92898#2521166, @mehdi_amini wrote:

In D92898#2520601, @jpienaar wrote:

I know there was another prototype in this region, does that subsume this?

I have this: https://reviews.llvm.org/D93085 but River had a suggestion about the implementation and I didn't come to finish trying this alternative.

I think what we have been discussing on D93085 is better, so we can continue improving that one.

mlir/docs/Interfaces.md

struct AffineInlinerInterface : public DialectInlinerInterface {
   /// Affine structures have specific inlining constraints.
   bool isLegalToInline(Region *dest, Region *src,
                        BlockAndValueMapping &valueMapping) const final {
     ...
   }
 };
 
 /// Register the interface with the dialect.
-AffineDialect::AffineDialect(MLIRContext *context) ... {
+void AffineDialect::initialize() {
   addInterfaces<AffineInlinerInterface>();
 }
 ```
 
 Once registered, these interfaces can be queried from the dialect by an analysis
 or transformation without the need to determine the specific dialect subclass:
 
 ```c++

 
 /// Later, we can query if a specific operation(like 'MyOp') overrides the given
 /// interface.
 Operation *op = ...;
 if (ExampleOpInterface example = dyn_cast<ExampleOpInterface>(op))
   llvm::errs() << "hook returned = " << example.exampleInterfaceHook() << "\n";
 ```
 
+#### Fallback Dialect Interfaces for Unregistered Operations
+
+The above mechanism requires that the IR entity be registered to implement the
+interface, but some dialects however, allow for unregistered operations. To
+support operation interfaces in such situations, a derived `OpInterface` may
+provide a dialect interface (named `DialectInterface`) that provides a fallback
+implementation. This interface acts similarly to the `Model` traits class, but
+must also include an additional hook: `bool isOpSupported(OperationName op)
+const` that filters which operations are supported by the fallback. An example
+is shown below:
+
+```c++
+/// Define the main interface class that analyses and transformations will
+/// interface with.
+class ExampleOpInterface : public OpInterface<ExampleOpInterface,
+                                              ExampleOpInterfaceTraits> {
+public:
+  /// ... The details from the earlier example are elided here ...
+
+  /// This class represents a dialect fallback implementation for unregistered
+  /// operations.
+  class DialectInterface
+      : public mlir::DialectInterface::Base<DialectInterface>,
+               ExampleOpInterfaceTraits::Concept {
+  public:
+    /// Returns true if the given unregistered operation is supported by this
+    /// fallback interface.
+    virtual bool isOpSupported(OperationName op) const = 0;
+  };
+};
+
+
+/// This class defines a fallback dialect interface for handling
+/// `ExampleOpInterface`.
+struct ExampleDialectFallbackInterface
+    : public ExampleOpInterface::DialectInterface {
+  using ExampleOpInterface::DialectInterface::DialectInterface;
+
+  /// Returns true if the given unregistered operation is supported by this
+  /// fallback interface.
+  bool isOpSupported(OperationName op) const final {
+    return op.getStringRef() == "example.unregistered_op";
+  }
+
+  /// Implementations of the interface concept hooks.
+  unsigned exampleInterfaceHook(Operation *op) const final {
+    // ...
+  }
+  unsigned exampleStaticInterfaceHook(OperationName op) const final {
+    // ...
+  }
+};
+
+/// Register the interface with the dialect.
+void ExampleDialect::initialize() {
+  addInterfaces<AffineInlinerInterface>();
+}
+
+/// The use of a fallback interface is transparent to users, with no changes
+/// required for the user facing code.
+Operation *op = ...;
+if (ExampleOpInterface example = dyn_cast<ExampleOpInterface>(op))
+  // ... ;
+```
+
 #### Utilizing the ODS Framework
 
 Note: Before reading this section, the reader should have some familiarity with
 the concepts described in the
 [`Operation Definition Specification`](OpDefinitions.md) documentation.
 
 As detailed above, [Interfaces](attribute-operation-type-interfaces) allow for
 attributes, operations, and types to expose method calls without requiring that
*   Methods (`methods`)
     -   The structure of these methods is defined below.
 *   Extra Class Declarations (Optional: `extraClassDeclaration`)
     -   Additional C++ code that is generated in the declaration of the
         interface class. This allows for defining methods and more on the user
         facing interface class, that do not need to hook into the IR entity.
 
 `OpInterface` classes may additionally contain the following:
 
+*   GenerateDialectFallback (`generateDialectFallback`)
+    -   Signal that a dialect interface fallback class should be generated for
+        this interface, to allow for dialects to provide an implementation for
+        unregistered operations.
 *   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.
 
 There are two types of methods that can be used with an interface,
 `InterfaceMethod` and `StaticInterfaceMethod`. They are both comprised of the

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterface.td

InterfaceMethod<
       }],
       /*retTy=*/"Operation *",
       /*methodName=*/"clone",
       (ins "OpBuilder &":$b, "Location":$loc, "TypeRange":$resultTypes,
            "ValueRange":$operands),
       [{
         BlockAndValueMapping map;
         unsigned numRegions = $_op->getNumRegions();
-        Operation *res = create(b, loc, resultTypes, operands, $_op.getAttrs());
+        Operation *res = b.create<ConcreteOp>(loc, resultTypes, operands,
+                                              $_op.getAttrs());
         assert(res->getNumRegions() == numRegions && "inconsistent # regions");
         for (unsigned ridx = 0; ridx < numRegions; ++ridx)
           $_op->getRegion(ridx).cloneInto(
             &res->getRegion(ridx), map);
         return res;
       }]
     >,
     StaticInterfaceMethod<

mlir/include/mlir/IR/OpBase.td

class OpInterfaceTrait<string name, code verifyBody = [{}]>
 
   // Specify the body of the verification function. `$_op` will be replaced with
   // the operation being verified.
   code verify = verifyBody;
 
   // An optional code block containing extra declarations to place in the
   // interface trait declaration.
   code extraTraitClassDeclaration = "";
+
+  // Specify that a fallback dialect interface should be generated for this
+  // interface. If set, a dialect interface class named `DialectInterface` will
+  // be generated within the interface class enabling for dialects to provide a
+  // fallback for unregistered operations.
+  bit generateDialectFallback = 0;
 }
 
 // This class represents a single, optionally static, interface method.
 // Note: non-static interface methods have an implicit parameter, either
 // $_op/$_attr/$_type corresponding to an instance of the derived value.
 class InterfaceMethod<string desc, string retTy, string methodName,
                       dag args = (ins), code methodBody = [{}],
                       code defaultImplementation = [{}]> {

mlir/include/mlir/IR/OpDefinition.h

 // The purpose of these types are to allow light-weight implementation of
 // concrete ops (like DimOp) with very little boilerplate.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_OPDEFINITION_H
 #define MLIR_IR_OPDEFINITION_H
 
+#include "mlir/IR/Dialect.h"
 #include "mlir/IR/Operation.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 
 #include <type_traits>
 
 namespace mlir {
 class Builder;
 class OpBuilder;
public:
   using Base = OpInterface<ConcreteType, Traits>;
   using InterfaceBase = detail::Interface<ConcreteType, Operation *, Traits,
                                           Op<ConcreteType>, OpTrait::TraitBase>;
 
   /// Inherit the base class constructor.
   using InterfaceBase::InterfaceBase;
 
 protected:
+  /// Trait to check if T provides a 'DialectInterface' class.
+  template <typename T, typename... Args>
+  using has_dialect_interface =
+      decltype(std::declval<typename T::DialectInterface>());
+  template <typename T>
+  using detect_has_dialect_interface =
+      llvm::is_detected<has_dialect_interface, T>;
+
   /// Returns the impl interface instance for the given operation.
-  static typename InterfaceBase::Concept *getInterfaceFor(Operation *op) {
+  static const typename InterfaceBase::Concept *getInterfaceFor(Operation *op) {
     // Access the raw interface from the abstract operation.
-    auto *abstractOp = op->getAbstractOperation();
-    return abstractOp ? abstractOp->getInterface<ConcreteType>() : nullptr;
+    if (auto *abstractOp = op->getAbstractOperation())
+      return abstractOp->getInterface<ConcreteType>();
+    return getDialectInterfaceFor<ConcreteType>(op);
+  }
+  /// This overload is selected when the interface does not have a dialect
+  /// interface fallback.
+  template <typename InterfaceT>
+  static std::enable_if_t<!detect_has_dialect_interface<InterfaceT>::value,
+                          const typename InterfaceT::Concept *>
+  getDialectInterfaceFor(Operation *op) {
+    return nullptr;
+  }
+  /// This overload is selected when the interface does have a dialect interface
+  /// fallback.
+  template <typename InterfaceT>
+  static std::enable_if_t<detect_has_dialect_interface<InterfaceT>::value,
+                          const typename InterfaceT::Concept *>
+  getDialectInterfaceFor(Operation *op) {
+    // If this operation isn't registered, try the dialect as a fallback.
+    MLIRContext *ctx = op->getContext();
+    if (Dialect *dialect = ctx->getLoadedDialect(op->getName().getDialect())) {
+      auto *interface = dialect->getRegisteredInterface<
+          typename ConcreteType::DialectInterface>();
+      if (interface && interface->isOpSupported(op->getName()))
+        return interface;
+    }
+    return nullptr;
   }
 
   /// Allow access to `getInterfaceFor`.
   friend InterfaceBase;
 };
 
 //===----------------------------------------------------------------------===//
 // Common Operation Folders/Parsers/Printers

mlir/include/mlir/IR/RegionKindInterface.td

let description = [{
     [SSA-style control flow](LangRef.md#modeling-control-flow) region
     with basic blocks, sequential semantics, and reachability.
   }];
   let cppNamespace = "::mlir";
 
   let methods = [
     StaticInterfaceMethod<
       /*desc=*/[{
-        Return the kind of the region with the given index inside this operation.
+        Return the kind of the region with the given index inside this
+        operation.
       }],
       /*retTy=*/"RegionKind",
       /*methodName=*/"getRegionKind",
       /*args=*/(ins "unsigned":$index)
     >,
-    StaticInterfaceMethod<
-      /*desc=*/"Return true if the kind of the given region requires the "
-               "SSA-Dominance property",
-      /*retTy=*/"bool",
-      /*methodName=*/"hasSSADominance",
-      /*args=*/(ins "unsigned":$index),
-      /*methodBody=*/[{
-        return getRegionKind(index) == RegionKind::SSACFG;
-      }]
-    >,
   ];
+  let extraClassDeclaration = [{
+    /// Return true if the kind of the given region requires the SSA-Dominance
+    /// property.
+    bool hasSSADominance(unsigned index) {
+      return getRegionKind(index) == RegionKind::SSACFG;
+    }
+  }];
 }
 
 #endif // MLIR_IR_REGIONKINDINTERFACE

mlir/include/mlir/Interfaces/SideEffectInterfaces.h

 //===- SideEffectInterfaces.h - SideEffect in MLIR --------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains traits, interfaces, and utilities for defining and
 // querying the side effects of an operation.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_INTERFACES_SIDEEFFECTS_H
 #define MLIR_INTERFACES_SIDEEFFECTS_H
 
+#include "mlir/IR/DialectInterface.h"
 #include "mlir/IR/OpDefinition.h"
 
 namespace mlir {
 namespace SideEffects {
 //===----------------------------------------------------------------------===//
 // Effects
 //===----------------------------------------------------------------------===//
 

mlir/include/mlir/Interfaces/SideEffectInterfaces.td

 def MemoryEffectsOpInterface
     : EffectOpInterfaceBase<"MemoryEffectOpInterface",
                             "::mlir::MemoryEffects::Effect"> {
   let description = [{
     An interface used to query information about the memory effects applied by
     an operation.
   }];
   let cppNamespace = "::mlir";
+
+  // Generate a fallback dialect interface for providing memory effects.
+  let generateDialectFallback = 1;
 }
 
 // The base class for defining specific memory effects.
 class MemoryEffect<string effectName, Resource resource>
   : SideEffect<MemoryEffectsOpInterface, effectName, resource>;
 
 // This class represents the trait for memory effects that may be placed on
 // operations.

mlir/include/mlir/Support/InterfaceSupport.h

public:
   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>(); }
 
 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;
+  const Concept *impl;
 };
 
 //===----------------------------------------------------------------------===//
 // InterfaceMap
 //===----------------------------------------------------------------------===//
 
 /// Utility to filter a given sequence of types base upon a predicate.
 template <bool>

mlir/include/mlir/TableGen/Interfaces.h

public:
   llvm::Optional<StringRef> getExtraClassDeclaration() const;
 
   // Return the traits extra class declaration code.
   llvm::Optional<StringRef> getExtraTraitClassDeclaration() const;
 
   // Return the verify method body if it has one.
   llvm::Optional<StringRef> getVerify() const;
 
+  // Returns true if this interface requested that a dialect interface fallback
+  // be generated.
+  bool shouldGenerateDialectFallback() 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.

mlir/lib/Rewrite/ByteCode.cpp

case CreateOperation: {
       if (hasInferredTypes) {
         InferTypeOpInterface::Concept *concept =
             state.name.getAbstractOperation()
                 ->getInterface<InferTypeOpInterface>();
 
         // TODO: Handle failure.
         SmallVector<Type, 2> inferredTypes;
         if (failed(concept->inferReturnTypes(
-                state.getContext(), state.location, state.operands,
+                state.name, state.getContext(), state.location, state.operands,
                 state.attributes.getDictionary(state.getContext()),
                 state.regions, inferredTypes)))
           return;
 
         for (unsigned i = 0, e = state.types.size(); i != e; ++i)
           if (!state.types[i])
             state.types[i] = inferredTypes[i];
       }

mlir/lib/TableGen/Interfaces.cpp

 llvm::Optional<StringRef> Interface::getVerify() const {
   // Only OpInterface supports the verify method.
   if (!isa<OpInterface>(this))
     return llvm::None;
   auto value = def->getValueAsString("verify");
   return value.empty() ? llvm::Optional<StringRef>() : value;
 }
 
+// Returns true if this interface requested that a dialect interface fallback
+// be generated.
+bool Interface::shouldGenerateDialectFallback() const {
+  // Only OpInterface supports the generateDialectFallback method.
+  if (!isa<OpInterface>(this))
+    return false;
+  return def->getValueAsBit("generateDialectFallback");
+}
+
 //===----------------------------------------------------------------------===//
 // AttrInterface
 //===----------------------------------------------------------------------===//
 
 bool AttrInterface::classof(const Interface *interface) {
   return interface->getDef().isSubClassOf("AttrInterface");
 }
 

mlir/test/IR/test-side-effects.mlir

 ]} : () -> i32
 
 // No _memory_ effects, but a parametric test effect.
 // expected-remark@+2 {{operation has no memory effects}}
 // expected-remark@+1 {{found a parametric effect with affine_map<(d0, d1) -> (d1, d0)>}}
 %4 = "test.side_effect_op"() {
   effect_parameter = affine_map<(i, j) -> (j, i)>
 } : () -> i32
+
+/// The following tests the same as above, but on an unregistered operation in
+/// the test dialect.
+
+// expected-remark@+1 {{operation has no memory effects}}
+%5 = "test.unknown_side_effect_op"() {} : () -> i32
+
+// expected-remark@+2 {{found an instance of 'read' on resource '<Default>'}}
+// expected-remark@+1 {{found an instance of 'free' on resource '<Default>'}}
+%6 = "test.unknown_side_effect_op"() {effects = [
+  {effect="read"}, {effect="free"}
+]} : () -> i32
+
+// expected-remark@+1 {{found an instance of 'write' on resource '<Test>'}}
+%7 = "test.unknown_side_effect_op"() {effects = [
+  {effect="write", test_resource}
+]} : () -> i32
+
+// expected-remark@+1 {{found an instance of 'allocate' on a value, on resource '<Test>'}}
+%8 = "test.unknown_side_effect_op"() {effects = [
+  {effect="allocate", on_result, test_resource}
+]} : () -> i32
+
+// expected-remark@+1 {{found an instance of 'read' on a symbol '@foo_ref', on resource '<Test>'}}
+"test.unknown_side_effect_op"() {effects = [
+  {effect="read", on_reference = @foo_ref, test_resource}
+]} : () -> i32

mlir/test/lib/Dialect/Test/TestDialect.cpp

 void mlir::test::registerTestDialect(DialectRegistry &registry) {
   registry.insert<TestDialect>();
 }
 
 //===----------------------------------------------------------------------===//
 // TestDialect Interfaces
 //===----------------------------------------------------------------------===//
 
-namespace {
-
-// Test support for interacting with the AsmPrinter.
-struct TestOpAsmInterface : public OpAsmDialectInterface {
-  using OpAsmDialectInterface::OpAsmDialectInterface;
-
-  LogicalResult getAlias(Attribute attr, raw_ostream &os) const final {
-    StringAttr strAttr = attr.dyn_cast<StringAttr>();
-    if (!strAttr)
-      return failure();
-
-    // Check the contents of the string attribute to see what the test alias
-    // should be named.
-    Optional<StringRef> aliasName =
-        StringSwitch<Optional<StringRef>>(strAttr.getValue())
-            .Case("alias_test:dot_in_name", StringRef("test.alias"))
-            .Case("alias_test:trailing_digit", StringRef("test_alias0"))
-            .Case("alias_test:prefixed_digit", StringRef("0_test_alias"))
-            .Case("alias_test:sanitize_conflict_a",
-                  StringRef("test_alias_conflict0"))
-            .Case("alias_test:sanitize_conflict_b",
-                  StringRef("test_alias_conflict0_"))
-            .Default(llvm::None);
-    if (!aliasName)
-      return failure();
-
-    os << *aliasName;
-    return success();
-  }
-
-  void getAsmResultNames(Operation *op,
-                         OpAsmSetValueNameFn setNameFn) const final {
-    if (auto asmOp = dyn_cast<AsmDialectInterfaceOp>(op))
-      setNameFn(asmOp, "result");
-  }
-
-  void getAsmBlockArgumentNames(Block *block,
-                                OpAsmSetValueNameFn setNameFn) const final {
-    auto op = block->getParentOp();
-    auto arrayAttr = op->getAttrOfType<ArrayAttr>("arg_names");
-    if (!arrayAttr)
-      return;
-    auto args = block->getArguments();
-    auto e = std::min(arrayAttr.size(), args.size());
-    for (unsigned i = 0; i < e; ++i) {
-      if (auto strAttr = arrayAttr[i].dyn_cast<StringAttr>())
-        setNameFn(args[i], strAttr.getValue());
-    }
-  }
-};
+/// Collect a set of side effects for the given operation, whose side effects
+/// are defined in an attached `effects` ArrayAttr.
+static void
+getTestSideEffectsFor(Operation *op,
+                      SmallVectorImpl<MemoryEffects::EffectInstance> &effects);
 
+namespace {
 struct TestDialectFoldInterface : public DialectFoldInterface {
   using DialectFoldInterface::DialectFoldInterface;
 
   /// Registered hook to check if the given region, which is attached to an
   /// operation that is *not* isolated from above, should be used when
   /// materializing constants.
   bool shouldMaterializeInto(Region *region) const final {
     // If this is a one region operation, then insert into it.
     return isa<OneRegionOp>(region->getParentOp());
   }
 };
 
-/// This class defines the interface for handling inlining with standard
-/// operations.
-struct TestInlinerInterface : public DialectInlinerInterface {
+/// This class defines the interface for handling inlining with test operations.
+struct TestDialectInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;
 
   //===--------------------------------------------------------------------===//
   // Analysis Hooks
   //===--------------------------------------------------------------------===//
 
   bool isLegalToInline(Operation *call, Operation *callable,
                        bool wouldBeCloned) const final {
Operation *materializeCallConversion(OpBuilder &builder, Value input,
     if (!(resultType.isSignlessInteger(16) ||
           resultType.isSignlessInteger(32)) ||
         !(input.getType().isSignlessInteger(16) ||
           input.getType().isSignlessInteger(32)))
       return nullptr;
     return builder.create<TestCastOp>(conversionLoc, resultType, input);
   }
 };
+
+/// Test support for interacting with the AsmPrinter.
+struct TestDialectOpAsmInterface : public OpAsmDialectInterface {
+  using OpAsmDialectInterface::OpAsmDialectInterface;
+
+  LogicalResult getAlias(Attribute attr, raw_ostream &os) const final {
+    StringAttr strAttr = attr.dyn_cast<StringAttr>();
+    if (!strAttr)
+      return failure();
+
+    // Check the contents of the string attribute to see what the test alias
+    // should be named.
+    Optional<StringRef> aliasName =
+        StringSwitch<Optional<StringRef>>(strAttr.getValue())
+            .Case("alias_test:dot_in_name", StringRef("test.alias"))
+            .Case("alias_test:trailing_digit", StringRef("test_alias0"))
+            .Case("alias_test:prefixed_digit", StringRef("0_test_alias"))
+            .Case("alias_test:sanitize_conflict_a",
+                  StringRef("test_alias_conflict0"))
+            .Case("alias_test:sanitize_conflict_b",
+                  StringRef("test_alias_conflict0_"))
+            .Default(llvm::None);
+    if (!aliasName)
+      return failure();
+
+    os << *aliasName;
+    return success();
+  }
+
+  void getAsmResultNames(Operation *op,
+                         OpAsmSetValueNameFn setNameFn) const final {
+    if (auto asmOp = dyn_cast<AsmDialectInterfaceOp>(op))
+      setNameFn(asmOp, "result");
+  }
+
+  void getAsmBlockArgumentNames(Block *block,
+                                OpAsmSetValueNameFn setNameFn) const final {
+    auto op = block->getParentOp();
+    auto arrayAttr = op->getAttrOfType<ArrayAttr>("arg_names");
+    if (!arrayAttr)
+      return;
+    auto args = block->getArguments();
+    auto e = std::min(arrayAttr.size(), args.size());
+    for (unsigned i = 0; i < e; ++i) {
+      if (auto strAttr = arrayAttr[i].dyn_cast<StringAttr>())
+        setNameFn(args[i], strAttr.getValue());
+    }
+  }
+};
+
+/// This class defines the fallback dialect interface for handling operation
+/// side effects.
+struct TestDialectSideEffectInterface
+    : public MemoryEffectOpInterface::DialectInterface {
+  using MemoryEffectOpInterface::DialectInterface::DialectInterface;
+
+  /// Returns true if the given unregistered operation is supported by this
+  /// fallback implementation.
+  bool isOpSupported(OperationName op) const override {
+    return op.getStringRef() == "test.unknown_side_effect_op";
+  }
+
+  /// Collects all of the operation's effects into `effects`.
+  void
+  getEffects(Operation *op,
+             SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
+                 &effects) const override {
+    assert(isOpSupported(op->getName()) && "expected supported operation");
+    return getTestSideEffectsFor(op, effects);
+  }
+};
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 // TestDialect
 //===----------------------------------------------------------------------===//
 
 void TestDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "TestOps.cpp.inc"
       >();
-  addInterfaces<TestOpAsmInterface, TestDialectFoldInterface,
-                TestInlinerInterface>();
+  addInterfaces<TestDialectOpAsmInterface, TestDialectFoldInterface,
+                TestDialectInlinerInterface, TestDialectSideEffectInterface>();
   addTypes<TestType, TestRecursiveType,
 #define GET_TYPEDEF_LIST
 #include "TestTypeDefs.cpp.inc"
            >();
   allowUnknownOperations();
 }
 
 static Type parseTestType(MLIRContext *ctxt, DialectAsmParser &parser,

 
 namespace {
 /// A test resource for side effects.
 struct TestResource : public SideEffects::Resource::Base<TestResource> {
   StringRef getName() final { return "<Test>"; }
 };
 } // end anonymous namespace
 
-void SideEffectOp::getEffects(
+/// Collect a set of side effects for the given operation, whose side effects
+/// are defined in an attached `effects` ArrayAttr.
+static void
+getTestSideEffectsFor(Operation *op,
                       SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   // Check for an effects attribute on the op instance.
-  ArrayAttr effectsAttr = getAttrOfType<ArrayAttr>("effects");
+  ArrayAttr effectsAttr = op->getAttrOfType<ArrayAttr>("effects");
   if (!effectsAttr)
     return;
 
   // If there is one, it is an array of dictionary attributes that hold
   // information on the effects of this operation.
   for (Attribute element : effectsAttr) {
     DictionaryAttr effectElement = element.cast<DictionaryAttr>();
 
     // Get the specific memory effect.
     MemoryEffects::Effect *effect =
         StringSwitch<MemoryEffects::Effect *>(
             effectElement.get("effect").cast<StringAttr>().getValue())
             .Case("allocate", MemoryEffects::Allocate::get())
             .Case("free", MemoryEffects::Free::get())
             .Case("read", MemoryEffects::Read::get())
             .Case("write", MemoryEffects::Write::get());
 
     // Check for a non-default resource to use.
     SideEffects::Resource *resource = SideEffects::DefaultResource::get();
     if (effectElement.get("test_resource"))
       resource = TestResource::get();
 
     // Check for a result to affect.
     if (effectElement.get("on_result"))
-      effects.emplace_back(effect, getResult(), resource);
+      effects.emplace_back(effect, op->getResult(0), resource);
     else if (Attribute ref = effectElement.get("on_reference"))
       effects.emplace_back(effect, ref.cast<SymbolRefAttr>(), resource);
     else
       effects.emplace_back(effect, resource);
   }
 }
 
 void SideEffectOp::getEffects(
+    SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
+  getTestSideEffectsFor(*this, effects);
+}
+
+void SideEffectOp::getEffects(
     SmallVectorImpl<TestEffects::EffectInstance> &effects) {
   auto effectsAttr = getAttrOfType<AffineMapAttr>("effect_parameter");
   if (!effectsAttr)
     return;
 
   effects.emplace_back(TestEffects::Concrete::get(), effectsAttr);
 }
 

mlir/tools/mlir-tblgen/OpInterfacesGen.cpp

 static raw_ostream &emitCPPType(StringRef type, raw_ostream &os) {
   type = type.trim();
   os << type;
   if (type.back() != '&' && type.back() != '*')
     os << " ";
   return os;
 }
 
-/// Emit the method name and argument list for the given method. If 'addThisArg'
-/// is true, then an argument is added to the beginning of the argument list for
-/// the concrete value.
-static void emitMethodNameAndArgs(const InterfaceMethod &method,
-                                  raw_ostream &os, StringRef valueType,
-                                  bool addThisArg, bool addConst) {
-  os << method.getName() << '(';
-  if (addThisArg)
-    emitCPPType(valueType, os)
-        << "tablegen_opaque_val" << (method.arg_empty() ? "" : ", ");
-  llvm::interleaveComma(method.getArguments(), os,
-                        [&](const InterfaceMethod::Argument &arg) {
-                          os << arg.type << " " << arg.name;
-                        });
-  os << ')';
-  if (addConst)
-    os << " const";
-}
-
 /// Get an array of all OpInterface definitions but exclude those subclassing
 /// "DeclareOpInterfaceMethods".
 static std::vector<llvm::Record *>
 getAllOpInterfaceDefinitions(const llvm::RecordKeeper &recordKeeper) {
   std::vector<llvm::Record *> defs =
       recordKeeper.getAllDerivedDefinitions("OpInterface");
 
   llvm::erase_if(defs, [](const llvm::Record *def) {
     return def->isSubClassOf("DeclareOpInterfaceMethods");
   });
   return defs;
 }
 
 namespace {
 /// This struct is the base generator used when processing tablegen interfaces.
 class InterfaceGenerator {
 public:
+  using Argument = InterfaceMethod::Argument;
+
   bool emitInterfaceDefs();
   bool emitInterfaceDecls();
   bool emitInterfaceDocs();
 
 protected:
   InterfaceGenerator(std::vector<llvm::Record *> &&defs, raw_ostream &os)
       : defs(std::move(defs)), os(os) {}
 
+  /// Emit the function type used to store the given method.
+  void emitMethodType(const InterfaceMethod &method);
+
+  /// Emit a call to the given method using the names of its arguments as
+  /// parameters.
+  void emitCallToMethod(const InterfaceMethod &method, bool addThisArg);
+
+  /// Emit the argument list for the given method. If 'addThisArg' is true, then
+  /// an argument is added to the beginning of the argument list for the
+  /// concrete value.
+  void emitMethodArgs(const InterfaceMethod &method, bool addThisArg,
+                      bool addConst);
+
+  void emitInterfaceDef(Interface interface);
   void emitConceptDecl(Interface &interface);
   void emitModelDecl(Interface &interface);
   void emitModelMethodsDef(Interface &interface);
   void emitTraitDecl(Interface &interface, StringRef interfaceName,
                      StringRef interfaceTraitsName);
+  void emitDialectInterfaceModelDecl(Interface &interface);
   void emitInterfaceDecl(Interface interface);
+  void emitInterfaceDoc(Interface interface);
 
   /// The set of interface records to emit.
   std::vector<llvm::Record *> defs;
   // The stream to emit to.
   raw_ostream &os;
   /// The C++ value type of the interface, e.g. Operation*.
   StringRef valueType;
+  /// The C++ value type of the interface used when the method is static, e.g.
+  /// OperationName.
+  StringRef staticValueType;
   /// The C++ base interface type.
   StringRef interfaceBaseType;
   /// The name of the typename for the value template.
   StringRef valueTemplate;
   /// The format context to use for methods.
   tblgen::FmtContext nonStaticMethodFmt;
   tblgen::FmtContext traitMethodFmt;
 };
 
 /// A specialized generator for attribute interfaces.
 struct AttrInterfaceGenerator : public InterfaceGenerator {
   AttrInterfaceGenerator(const llvm::RecordKeeper &records, raw_ostream &os)
       : InterfaceGenerator(records.getAllDerivedDefinitions("AttrInterface"),
                            os) {
     valueType = "::mlir::Attribute";
+    staticValueType = valueType;
     interfaceBaseType = "AttributeInterface";
     valueTemplate = "ConcreteAttr";
     StringRef castCode = "(tablegen_opaque_val.cast<ConcreteAttr>())";
     nonStaticMethodFmt.addSubst("_attr", castCode).withSelf(castCode);
     traitMethodFmt.addSubst("_attr",
                             "(*static_cast<const ConcreteAttr *>(this))");
   }
 };
 /// A specialized generator for operation interfaces.
 struct OpInterfaceGenerator : public InterfaceGenerator {
   OpInterfaceGenerator(const llvm::RecordKeeper &records, raw_ostream &os)
       : InterfaceGenerator(getAllOpInterfaceDefinitions(records), os) {
     valueType = "::mlir::Operation *";
+    staticValueType = "::mlir::OperationName";
     interfaceBaseType = "OpInterface";
     valueTemplate = "ConcreteOp";
     StringRef castCode = "(llvm::cast<ConcreteOp>(tablegen_opaque_val))";
     nonStaticMethodFmt.withOp(castCode).withSelf(castCode);
     traitMethodFmt.withOp("(*static_cast<ConcreteOp *>(this))");
   }
 };
 /// A specialized generator for type interfaces.
 struct TypeInterfaceGenerator : public InterfaceGenerator {
   TypeInterfaceGenerator(const llvm::RecordKeeper &records, raw_ostream &os)
       : InterfaceGenerator(records.getAllDerivedDefinitions("TypeInterface"),
                            os) {
     valueType = "::mlir::Type";
+    staticValueType = valueType;
     interfaceBaseType = "TypeInterface";
     valueTemplate = "ConcreteType";
     StringRef castCode = "(tablegen_opaque_val.cast<ConcreteType>())";
     nonStaticMethodFmt.addSubst("_type", castCode).withSelf(castCode);
     traitMethodFmt.addSubst("_type",
                             "(*static_cast<const ConcreteType *>(this))");
   }
 };
 } // end anonymous namespace
 
+void InterfaceGenerator::emitMethodType(const InterfaceMethod &method) {
+  os << method.getReturnType() << "("
+     << (method.isStatic() ? staticValueType : valueType)
+     << (method.arg_empty() ? "" : ", ");
+  llvm::interleaveComma(method.getArguments(), os,
+                        [&](const Argument &arg) { os << arg.type; });
+  os << ")";
+}
+
+void InterfaceGenerator::emitCallToMethod(const InterfaceMethod &method,
+                                          bool addThisArg) {
+  os << method.getName() << '(';
+  if (addThisArg)
+    os << "tablegen_opaque_val" << (method.arg_empty() ? "" : ", ");
+  llvm::interleaveComma(method.getArguments(), os,
+                        [&](const Argument &arg) { os << arg.name; });
+  os << ')';
+}
+
+void InterfaceGenerator::emitMethodArgs(const InterfaceMethod &method,
+                                        bool addThisArg, bool addConst) {
+  if (addThisArg) {
+    emitCPPType(method.isStatic() ? staticValueType : valueType, os);
+    os << "tablegen_opaque_val" << (method.arg_empty() ? "" : ", ");
+  }
+  llvm::interleaveComma(method.getArguments(), os, [&](const Argument &arg) {
+    os << arg.type << " " << arg.name;
+  });
+  os << ')';
+  if (addConst)
+    os << " const";
+}
+
 //===----------------------------------------------------------------------===//
 // GEN: Interface definitions
 //===----------------------------------------------------------------------===//
 
-static void emitInterfaceDef(Interface interface, StringRef valueType,
-                             raw_ostream &os) {
+void InterfaceGenerator::emitInterfaceDef(Interface interface) {
   StringRef interfaceName = interface.getName();
   StringRef cppNamespace = interface.getCppNamespace();
   cppNamespace.consume_front("::");
 
   // Insert the method definitions.
   bool isOpInterface = isa<OpInterface>(interface);
   for (auto &method : interface.getMethods()) {
     emitCPPType(method.getReturnType(), os);
     if (!cppNamespace.empty())
       os << cppNamespace << "::";
-    os << interfaceName << "::";
-    emitMethodNameAndArgs(method, os, valueType, /*addThisArg=*/false,
-                          /*addConst=*/!isOpInterface);
+    os << interfaceName << "::" << method.getName() << '(';
+    emitMethodArgs(method, /*addThisArg=*/false,
 
     // Forward to the method on the concrete operation type.
     os << " {\n      return getImpl()->" << method.getName() << '(';
-    if (!method.isStatic()) {
-      os << (isOpInterface ? "getOperation()" : "*this");
-      os << (method.arg_empty() ? "" : ", ");
-    }
-    llvm::interleaveComma(
-        method.getArguments(), os,
-        [&](const InterfaceMethod::Argument &arg) { os << arg.name; });
+    if (isOpInterface)
+      os << "getOperation()" << (method.isStatic() ? "->getName()" : "");
+    else
+      os << "*this";
+    llvm::interleaveComma(method.getArguments(), os,
+                          [&](const Argument &arg) { os << arg.name; });
     os << ");\n  }\n";
   }
 }
 
 bool InterfaceGenerator::emitInterfaceDefs() {
   llvm::emitSourceFileHeader("Interface Definitions", os);
 
   for (const auto *def : defs)
-    emitInterfaceDef(Interface(def), valueType, os);
+    emitInterfaceDef(Interface(def));
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // GEN: Interface declarations
 //===----------------------------------------------------------------------===//
 
 void InterfaceGenerator::emitConceptDecl(Interface &interface) {
   os << "  struct Concept {\n";
 
   // Insert each of the pure virtual concept methods.
   for (auto &method : interface.getMethods()) {
-    os << "    ";
-    emitCPPType(method.getReturnType(), os);
-    os << "(*" << method.getName() << ")(";
-    if (!method.isStatic())
-      emitCPPType(valueType, os) << (method.arg_empty() ? "" : ", ");
-    llvm::interleaveComma(
-        method.getArguments(), os,
-        [&](const InterfaceMethod::Argument &arg) { os << arg.type; });
-    os << ");\n";
+    os << "    llvm::function_ref<";
+    emitMethodType(method);
+    os << "> " << method.getName() << ";\n";
   }
   os << "  };\n";
 }
 
 void InterfaceGenerator::emitModelDecl(Interface &interface) {
-  os << "  template<typename " << valueTemplate << ">\n";
-  os << "  class Model : public Concept {\n  public:\n";
-  os << "    Model() : Concept{";
-  llvm::interleaveComma(
-      interface.getMethods(), os,
-      [&](const InterfaceMethod &method) { os << method.getName(); });
-  os << "} {}\n\n";
+  os << "  template<typename " << valueTemplate << ">\n"
+     << "  class Model : public Concept {\n  public:\n    Model();\n";
 
   // Insert each of the virtual method overrides.
   for (auto &method : interface.getMethods()) {
-    emitCPPType(method.getReturnType(), os << "    static inline ");
-    emitMethodNameAndArgs(method, os, valueType,
-                          /*addThisArg=*/!method.isStatic(),
-                          /*addConst=*/false);
+    emitCPPType(method.getReturnType(), os << "    static inline ")
+        << method.getName() << '(';
+    emitMethodArgs(method, /*addThisArg=*/true, /*addConst=*/false);
     os << ";\n";
   }
   os << "  };\n";
 }
 
 void InterfaceGenerator::emitModelMethodsDef(Interface &interface) {
+  os << "template<typename " << valueTemplate << ">\n"
+     << "detail::" << interface.getName() << "InterfaceTraits::Model<"
+     << valueTemplate << ">::Model::Model() : Concept{";
+  llvm::interleaveComma(
+      interface.getMethods(), os,
+      [&](const InterfaceMethod &method) { os << method.getName(); });
+  os << "} {}\n";
+
   for (auto &method : interface.getMethods()) {
     os << "template<typename " << valueTemplate << ">\n";
     emitCPPType(method.getReturnType(), os);
     os << "detail::" << interface.getName() << "InterfaceTraits::Model<"
-       << valueTemplate << ">::";
-    emitMethodNameAndArgs(method, os, valueType,
-                          /*addThisArg=*/!method.isStatic(),
-                          /*addConst=*/false);
+       << valueTemplate << ">::" << method.getName() << '(';
+    emitMethodArgs(method, /*addThisArg=*/true, /*addConst=*/false);
     os << " {\n  ";
 
     // Check for a provided body to the function.
     if (Optional<StringRef> body = method.getBody()) {
       if (method.isStatic())
         os << body->trim();
       else
         os << tblgen::tgfmt(body->trim(), &nonStaticMethodFmt);
       os << "\n}\n";
       continue;
     }
 
     // Forward to the method on the concrete operation type.
     if (method.isStatic())
       os << "return " << valueTemplate << "::";
     else
       os << tblgen::tgfmt("return $_self.", &nonStaticMethodFmt);
 
     // Add the arguments to the call.
-    os << method.getName() << '(';
-    llvm::interleaveComma(
-        method.getArguments(), os,
-        [&](const InterfaceMethod::Argument &arg) { os << arg.name; });
-    os << ");\n}\n";
+    emitCallToMethod(method, /*addThisArg=*/false);
+    os << ";\n}\n";
   }
 }
 
 void InterfaceGenerator::emitTraitDecl(Interface &interface,
                                        StringRef interfaceName,
                                        StringRef interfaceTraitsName) {
   os << llvm::formatv("  template <typename {3}>\n"
                       "  struct {0}Trait : public ::mlir::{2}<{0},"
if (method.getName() == "verifyTrait")
           formatv("'verifyTrait' method cannot be specified as interface "
                   "method for '{0}'; use the 'verify' field instead",
                   interfaceName));
     auto defaultImpl = method.getDefaultImplementation();
     if (!defaultImpl)
       continue;
 
     os << "    " << (method.isStatic() ? "static " : "");
-    emitCPPType(method.getReturnType(), os);
-    emitMethodNameAndArgs(method, os, valueType, /*addThisArg=*/false,
-                          /*addConst=*/!isOpInterface);
+    emitCPPType(method.getReturnType(), os) << method.getName() << '(';
+    emitMethodArgs(method, /*addThisArg=*/false,
     os << " {\n      " << tblgen::tgfmt(defaultImpl->trim(), &traitMethodFmt)
        << "\n    }\n";
   }
 
   if (auto verify = interface.getVerify()) {
     assert(isa<OpInterface>(interface) && "only OpInterface supports 'verify'");
 
     tblgen::FmtContext verifyCtx;
     verifyCtx.withOp("op");
     os << "    static ::mlir::LogicalResult verifyTrait(::mlir::Operation *op) "
           "{\n      "
        << tblgen::tgfmt(verify->trim(), &verifyCtx) << "\n    }\n";
   }
   if (auto extraTraitDecls = interface.getExtraTraitClassDeclaration())
     os << tblgen::tgfmt(*extraTraitDecls, &traitMethodFmt) << "\n";
 
   os << "  };\n";
 
   // Emit a utility wrapper trait class.
   os << llvm::formatv("  template <typename {1}>\n"
                       "  struct Trait : public {0}Trait<{1}> {{};\n",
                       interfaceName, valueTemplate);
 }
 
+/// Returns true if the given method body can be reused by a dialect interface
+/// fallback. Returns false if the method will need to be reimplemented by the
+/// derived interface.
+static bool canUseMethodBodyInDialectInterface(StringRef body, bool isStatic,
+                                               StringRef valueTemplate) {
+  // Check that the value template and replacements aren't used in the body.
+  if (body.contains(valueTemplate))
+    return false;
+
+  // Check that the replacements for the current value aren't used.
+  return isStatic || (!body.contains("$_self") && !body.contains("$_op"));
+}
+
+void InterfaceGenerator::emitDialectInterfaceModelDecl(Interface &interface) {
+  // Emit the dialect interface definition.
+  os << "  class DialectInterface : public "
+        "::mlir::DialectInterface::Base<DialectInterface>, public Concept {\n"
+        "  public:\n"
+        "    DialectInterface(::mlir::Dialect *dialect) : "
+        "Base(dialect), Concept{";
+
+  // We forward to an impl implemenation to allow for a virtual interface
+  // specifically for the dialect interface.
+  llvm::interleaveComma(interface.getMethods(), os,
+                        [&](const InterfaceMethod &method) {
+                          os << "__impl_" << method.getName();
+                        });
+  os << "} {}\n\n";
+
+  // Implement the dialect interface hooks for the Concept.
+  for (auto &method : interface.getMethods()) {
+    os << "  virtual ";
+    emitCPPType(method.getReturnType(), os) << method.getName() << '(';
+    emitMethodArgs(method, /*addThisArg=*/true, /*addConst=*/true);
+
+    // Check for a provided body to the function.
+    if (Optional<StringRef> body = method.getBody()) {
+      if (canUseMethodBodyInDialectInterface(*body, method.isStatic(),
+                                             valueTemplate)) {
+        os << " {\n  ";
+        if (method.isStatic())
+          os << body->trim();
+        else
+          os << tblgen::tgfmt(body->trim(), &nonStaticMethodFmt);
+        os << "\n}\n";
+        continue;
+      }
+    }
+
+    // Otherwise, this method must be implemented by the derived interface.
+    os << " = 0;\n";
+  }
+
+  // Emit the selector method that the dialect can use to filter supported
+  // unregistered operations.
+  os << "    /// Returns true if the given unregistered operation is\n"
+        "    /// supported by this fallback implementation.\n"
+        "    virtual bool isOpSupported(::mlir::OperationName op) const = 0;\n"
+     << "\n  private:\n";
+
+  // Implement the internal implementations for the Concept methods that forward
+  // to the dialect interface variants.
+  for (auto &method : interface.getMethods()) {
+    os << "    std::function<";
+    emitMethodType(method);
+    os << "> __impl_" << method.getName() << " = \n      [this](";
+    emitMethodArgs(method, /*addThisArg=*/true, /*addConst=*/false);
+    os << " {\n      return ";
+    emitCallToMethod(method, /*addThisArg=*/true);
+    os << ";\n    };\n";
+  }
+  os << "  };\n";
+}
+
 void InterfaceGenerator::emitInterfaceDecl(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();
os << llvm::formatv("class {0} : public ::mlir::{3}<{1}, detail::{2}> {\n"
                       interfaceBaseType);
 
   // Emit the derived trait for the interface.
   emitTraitDecl(interface, interfaceName, interfaceTraitsName);
 
   // Insert the method declarations.
   bool isOpInterface = isa<OpInterface>(interface);
   for (auto &method : interface.getMethods()) {
-    emitCPPType(method.getReturnType(), os << "  ");
-    emitMethodNameAndArgs(method, os, valueType, /*addThisArg=*/false,
-                          /*addConst=*/!isOpInterface);
+    emitCPPType(method.getReturnType(), os << "  ") << method.getName() << '(';
+    emitMethodArgs(method, /*addThisArg=*/false,
     os << ";\n";
   }
 
   // Emit any extra declarations.
   if (Optional<StringRef> extraDecls = interface.getExtraClassDeclaration())
     os << *extraDecls << "\n";
 
+  if (interface.shouldGenerateDialectFallback())
+    emitDialectInterfaceModelDecl(interface);
   os << "};\n";
 
   emitModelMethodsDef(interface);
 
   for (StringRef ns : llvm::reverse(namespaces))
     os << "} // namespace " << ns << "\n";
 }
 
 bool InterfaceGenerator::emitInterfaceDecls() {
   llvm::emitSourceFileHeader("Interface Declarations", os);
 
   for (const auto *def : defs)
     emitInterfaceDecl(Interface(def));
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // GEN: Interface documentation
 //===----------------------------------------------------------------------===//
 
-static void emitInterfaceDoc(const llvm::Record &interfaceDef,
-                             raw_ostream &os) {
-  Interface interface(&interfaceDef);
-
+void InterfaceGenerator::emitInterfaceDoc(Interface interface) {
   // Emit the interface name followed by the description.
-  os << "## " << interface.getName() << " (" << interfaceDef.getName() << ")";
+  os << "## " << interface.getName() << " (" << interface.getDef().getName()
+     << ")";
   if (auto description = interface.getDescription())
     mlir::tblgen::emitDescription(*description, os);
 
   // Emit the methods required by the interface.
   os << "\n### Methods:\n";
   for (const auto &method : interface.getMethods()) {
     // Emit the method name.
     os << "#### `" << method.getName() << "`\n\n```c++\n";
 
     // Emit the method signature.
     if (method.isStatic())
       os << "static ";
     emitCPPType(method.getReturnType(), os) << method.getName() << '(';
-    llvm::interleaveComma(method.getArguments(), os,
-                          [&](const InterfaceMethod::Argument &arg) {
-                            emitCPPType(arg.type, os) << arg.name;
-                          });
-    os << ");\n```\n";
+    emitMethodArgs(method, /*addThisArg=*/false, /*addConst=*/false);
+    os << ";\n```\n";
 
     // Emit the description.
     if (auto description = method.getDescription())
       mlir::tblgen::emitDescription(*description, os);
 
     // If the body is not provided, this method must be provided by the user.
     if (!method.getBody())
       os << "\nNOTE: This method *must* be implemented by the user.\n\n";
   }
 }
 
 bool InterfaceGenerator::emitInterfaceDocs() {
   os << "<!-- Autogenerated by mlir-tblgen; don't manually edit -->\n";
   os << "# " << interfaceBaseType << " definitions\n";
 
   for (const auto *def : defs)
-    emitInterfaceDoc(*def, os);
+    emitInterfaceDoc(Interface(def));
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // GEN: Interface registration hooks
 //===----------------------------------------------------------------------===//
 
 namespace {