[mlir] Add support for "promised" interfaces

[rriddle]

Summary

Promised interfaces allow for a dialect to "promise" the implementation of an interface, i.e.
declare that it supports an interface, but have the interface defined in an extension in a library
separate from the dialect itself. A promised interface is powerful in that it alerts the user when
the interface is attempted to be used (e.g. via cast/dyn_cast/etc.) and the implementation has
not yet been provided. This makes the system much more robust against misconfiguration,
and ensures that we do not lose the benefit we currently have of defining the interface in
the dialect library.

[springerm]

This revision is already quite old now but I rebased the "promised interfaces" part (D146414) and it worked well. Would be great to get this landed. I'm preparing a stack of revisions for a new interface with external model impls (D145681) and it would benefit from this revision.

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

24 ↗

(On Diff #410671)

This where the interface is defined. Based on the RFC (https://discourse.llvm.org/t/rfc-dialect-extensions-and-promised-interfaces/60451/3) I thought this dependency could be removed.

The only thing that is important is the type name of the interface (for the declarePromisedInterface API), which can be grabbed (e.g. via forward declaration) in ways such that you don’t depend on the library where the interface is defined.

But I think a forward declaration of the interface is not enough because it doesn't have the type ID of the interface. So this "promised interface" mechanism will not work for the BufferizableOpInterface which is defined in the bufferization dialect. Still, it would already improve the situation a lot for the majority of the interfaces, which are defined in mlir/Interfaces.

[wrengr]

This commit breaks Bazel: https://buildkite.com/llvm-project/upstream-bazel/builds/64887#0188a16c-a007-47f6-9324-11b5132b31ea

The root cause (or at least one major issue) is that mlir-opt.cpp can't find the "mlir/include/mlir/InitAllExtensions.h" header. But since the cmake files don't care much about headers I'm having trouble reconstructing the intent. Can you post a fix?

[rriddle]

In D120368#4409958, @wrengr wrote:

This commit breaks Bazel: https://buildkite.com/llvm-project/upstream-bazel/builds/64887#0188a16c-a007-47f6-9324-11b5132b31ea

The root cause (or at least one major issue) is that mlir-opt.cpp can't find the "mlir/include/mlir/InitAllExtensions.h" header. But since the cmake files don't care much about headers I'm having trouble reconstructing the intent. Can you post a fix?

Bazel isn't required to support and I don't have bazel setup to fix anything, so unfortunately I won't be able to help here.

[ftynse]

After updating a dozen of dependent projects to account for this change, I have concerns about usability.

Practically, promised dialects create a rather tight coupling between a dialect with a promised interface and an extension that realizes that promise. This makes the extension mandatory, which conceptually contradicts the notion of extension. Specifically, func dialect is now unusable without the extension that implements the inliner interface. I haven't had time to dig deeper into this, but it appears that it is the case even when the interface isn't ever requested by the user code.

Furthermore, it is often impossible to register the extension as a dependency of the pass, beyond the need to do it manually rather than in .td of the pass declaration. Specifically, extension registration in multithreaded mode (even when the same extensions are present in the registry) triggers an assertion due to https://github.com/llvm/llvm-project/blob/bae2e56115d617cc5e152b4743484ab04649fe13/mlir/lib/IR/Dialect.cpp#L269-L271 and extensions not having a TypeID that could be used to deduplicate them. This happens for projects that create a pass manager inside a pass run by another pass manager. I would consider this practice dubious, but it is quite common.

To complicate the matters, the error message omits the dialect name most of the time and reads like there it is itself buggy: "checking for an interface (``) that was promised by dialect 'func' but never implemented.", is interface nullptr? Something went wrong with registration before so there is no name? Certainly it should be possible to use, e.g., macro stringization to print at least the C++ class name of the missing interface.

[rnk]

I'm not very familiar with MLIR, dialects, extensions, etc, but from my perspective, this change seems to create more API update churn than the MLIR developer policy

When performing breaking changes, we expect to proceed with the most convenient way for the change to be reviewed and implemented, while minimizing churn. It is frequent to break changes in multiple commits to ease the review process. A breaking can be implemented incrementally within these guidelines, but we don’t go out of our way only to accomodate downstream users. As such we don’t have predefined deprecation period for APIs. A good practice is to communicate on Discourse about the timeline and plan for conducting such changes.

My understanding is that every essentially all code initializing an MLIR context, such as the toy examples in this CL, need an update to register function extensions. So, it affects every single user, which seems like gratuitous churn, as described in the paragraph above. I can't say what a dialect or an extension are or how they relate or depend on each other, but it seems like this could have been implemented transparently by registering extensions as part of registering dialects, which seems like something that every client already does when initializing an MLIR context.

I can't say what the right approach here is, but there are other tradeoffs on the spectrum between rapid development and minimizing churn, which is a stated goal of the developer policy. I encourage the project to weigh that goal with more care in the future.

mlir/examples/toy/Ch7/toyc.cpp

295

This seems like the most representative change required of essentially all clients initializing MLIR.

[rnk]

In D120368#4438249, @rnk wrote:

My understanding is that every essentially all code initializing an MLIR context, such as the toy examples in this CL, need an update to register function extensions. So, it affects every single user, which seems like gratuitous churn, as described in the paragraph above.

After thinking more about this, MLIR update churn is super common, and the volume this change creates is probably inline with that. I think what made this different was that failures manifested at runtime, which makes API updates much more expensive, and that's something to consider when evaluating changes.

[springerm]

I am wondering why this changes requires any downstream fixes at all. The purpose of this change is to give users an error when an external model is not registered (to avoid misconfiguration). This error is triggered when casting to an op interface for which an external model exists, but that was not registered.

E.g.:

tensor::ExtractOp op;
// error if `ExtractOpInterface` in `BufferizableOpInterfaceImpl.cpp` is not registered
cast<BufferizableOpInterface>(op.getOperation());

It was my understanding that, as long as there is no cast to the interface (for which the registration is missing), there should be no runtime error. Similarly, *if* there is such a cast, and the model is not registered, this piece of code is likely not working correctly, because the cast cannot succeed. (Similarly, isa<...> returns false, even though the op does implement that interface and the model is just not registered.) Consequently, every time we are seeing an error (caused by this revision) in a downstream project, we are actually detecting a bug/misconfiguration in the project, that just went unnoticed until now. Does this make sense?

Now, there seems to be something special about func extensions and the inliner here, because that's the only component that seems to cause issues with many downstream projects...

[ftynse]

I am wondering why this changes requires any downstream fixes at all. The purpose of this change is to give users an error when an external model is not registered (to avoid misconfiguration). This error is triggered when casting to an op interface for which an external model exists, but that was not registered.

It was my understanding that, as long as there is no cast to the interface (for which the registration is missing), there should be no runtime error. Similarly, *if* there is such a cast, and the model is not registered, this piece of code is likely not working correctly, because the cast cannot succeed. (Similarly, isa<...> returns false, even though the op does implement that interface and the model is just not registered.) Consequently, every time we are seeing an error (caused by this revision) in a downstream project, we are actually detecting a bug/misconfiguration in the project, that just went unnoticed until now. Does this make sense?

There is a description of the problem in my answer above. This change not only implements the promised interfaces feature, but also immediately uses it for implementing the inliner interface of the func dialect. I haven't had time yet to check if it indeed works if nobody requests this interface, but that's not the point.

While we did discover some additional misconfigurations in downstream projects in the process of debugging this, most of them were not misconfigured before this change. Prior to this change, it was sufficient for them to register the func dialect that came with the inliner interface implementation. After this change, it became necessary for them to also register the inliner interface implementation that _no longer_ comes with the dialect. This requires an explicit change and makes previously-correct configuration incorrect, with no warning.

Furthermore, using extension makes it impossible to add the interface in the getDependentDialects of a pass in the general case (see explanation above for the special case) in case it is needed down the road. Again, the pass was correctly registering the func dialect as dependent prior to this change. This also makes previously-correct configurations incorrect, and difficult to debug except for the situations where all registration happens upfront instead of progressively as pass dependencies.

[ftynse]

The purpose of this change is to give users an error when an external model is not registered (to avoid misconfiguration).

Also, the change isn't very good to doing exactly that: the error message doesn't specify the model for which interface is missing in the overwhelming majority of cases.

[Hardcode84]

We have also hit this issue with quite an unhelpful error message

LLVM ERROR: checking for an interface (``) that was promised by dialect 'func' but never implemented. This is generally an indication that the dialect extension implementing the interface was never registered.

And I also don't understand why this change was needed for func dialect specifically as it wasn't elaborated in commit description. Can we revert func dialect change?

[ftynse]

Given that it's been two weeks since it was landed, I would not push for revert as downstreams may have adapted already and it would cause additional churn.

I suppose the change in func was a way to "test" the functionality since there don't seem to be any unit tests.

@Hardcode84 to fix that error, find all places where MLIRContext is created and add both the func dialect and the inliner extension at that point. We did this by printing the stack trace from the MLIRContext constructor (binaries like tf-opt crash the linker if building in mode...).

[Hardcode84]

In D120368#4443677, @ftynse wrote:

Given that it's been two weeks since it was landed, I would not push for revert as downstreams may have adapted already and it would cause additional churn.

I suppose the change in func was a way to "test" the functionality since there don't seem to be any unit tests.

@Hardcode84 to fix that error, find all places where MLIRContext is created and add both the func dialect and the inliner extension at that point. We did this by printing the stack trace from the MLIRContext constructor (binaries like tf-opt crash the linker if building in mode...).

We have already figured the fix, thanks, although it looks quite ugly in our case, as we need to register extension before context creation https://github.com/numba/numba-mlir/pull/145/files#diff-236f1f75d31eb1df427f7a1ccbf72e05d02497200d680e73348970aca3c5bd69R830

I would still vote for revert, as it will only be a compile-time breakage, not the run-time as previous one.

[rriddle]

In D120368#4443856, @Hardcode84 wrote:

In D120368#4443677, @ftynse wrote:

Given that it's been two weeks since it was landed, I would not push for revert as downstreams may have adapted already and it would cause additional churn.

I suppose the change in func was a way to "test" the functionality since there don't seem to be any unit tests.

@Hardcode84 to fix that error, find all places where MLIRContext is created and add both the func dialect and the inliner extension at that point. We did this by printing the stack trace from the MLIRContext constructor (binaries like tf-opt crash the linker if building in mode...).

We have already figured the fix, thanks, although it looks quite ugly in our case, as we need to register extension before context creation https://github.com/numba/numba-mlir/pull/145/files#diff-236f1f75d31eb1df427f7a1ccbf72e05d02497200d680e73348970aca3c5bd69R830

I would still vote for revert, as it will only be a compile-time breakage, not the run-time as previous one.

We should certainly not revert. The func changes are intentional, given we previously had a dep on ControlFlow that was only there for the inliner interface.

[Hardcode84]

We should certainly not revert. The func changes are intentional, given we previously had a dep on ControlFlow that was only there for the inliner interface.

IMO, solution here causes more issues for users than the problem itself.

• I would prefer inliner pass to gracefully fail if extension wasn't registered instead of random abort with cryptic error message.
• It DOES found legitimate problems (https://github.com/numba/numba-mlir/pull/145/files#diff-0e6154dff4e912fccd60d7837fe6bfe6c00e385619f26bd7f157e3720b833fb9R100) but they wasn't detected upstream as most users (including mlir-opt) will just register all extensions upfront. This defeats the entire purpose of this change.

[mehdi_amini]

In D120368#4425402, @ftynse wrote:

Practically, promised dialects create a rather tight coupling between a dialect with a promised interface and an extension that realizes that promise.

Can you clarify where is the coupling between the dialect and the extension?

This makes the extension mandatory, which conceptually contradicts the notion of extension.

I don't quite get the contradiction: the intent here is that we promise that the extension will be available (when needed), without any coupling to the actual implementation. The provider is free to supply an extension however they wish.

Specifically, func dialect is now unusable without the extension that implements the inliner interface. I haven't had time to dig deeper into this, but it appears that it is the case even when the interface isn't ever requested by the user code.

I'd be interested in a test case, right now I can't reproduce.
I commented out registerAllExtensions() in mlir-opt.cpp, and re-run check-mlir:

********************
Failed Tests (20):
  MLIR :: Conversion/AsyncToLLVM/convert-to-llvm.mlir
  MLIR :: Conversion/AsyncToLLVM/typed-pointers.mlir
  MLIR :: Dialect/Affine/inlining.mlir
  MLIR :: Dialect/Async/async-parallel-for-canonicalize.mlir
  MLIR :: Dialect/Async/async-parallel-for-compute-fn.mlir
  MLIR :: Dialect/Async/async-to-async-runtime.mlir
  MLIR :: Dialect/Bufferization/inlining.mlir
  MLIR :: Dialect/GPU/outlining.mlir
  MLIR :: Dialect/LLVMIR/inlining.mlir
  MLIR :: Dialect/Linalg/inlining.mlir
  MLIR :: Dialect/Tosa/inlining.mlir
  MLIR :: Examples/Toy/Ch5/affine-lowering.mlir
  MLIR :: Transforms/inlining-dce.mlir
  MLIR :: Transforms/inlining-recursive.mlir
  MLIR :: Transforms/inlining-repeated-use.mlir
  MLIR :: Transforms/inlining.mlir
  MLIR :: Transforms/test-inlining.mlir
  MLIR :: Transforms/test-legalizer-full.mlir
  MLIR :: Transforms/test-legalizer.mlir
  MLIR :: mlir-cpu-runner/async-group.mlir


Testing Time: 39.21s
  Unsupported:  265
  Passed     : 1872
  Failed     :   20

This seems consistent with the expected behavior I believe?

Furthermore, it is often impossible to register the extension as a dependency of the pass, beyond the need to do it manually rather than in .td of the pass declaration. Specifically, extension registration in multithreaded mode (even when the same extensions are present in the registry) triggers an assertion due to https://github.com/llvm/llvm-project/blob/bae2e56115d617cc5e152b4743484ab04649fe13/mlir/lib/IR/Dialect.cpp#L269-L271 and extensions not having a TypeID that could be used to deduplicate them. This happens for projects that create a pass manager inside a pass run by another pass manager. I would consider this practice dubious, but it is quite common.

The case you describe seems WAI if I understand correctly: the enclosing pass that is wrapping an inner pass-manager (not clear to me why it can't be replaced by the dynamic pipeline instead, but that's not changing the setup for this) should add it to the registry in the getDependentDialects() call.
I tried commenting out registerAllExtensions() in mlir-opt.cpp, and moving it to a getDependentDialects() in the InlinerPass:

void getDependentDialects(DialectRegistry &registry) const override {
  mlir::func::registerInlinerExtension(registry);
}

And ninja check-mlir is passing. Maybe I misunderstood what you're describing though?

To complicate the matters, the error message omits the dialect name most of the time and reads like there it is itself buggy: "checking for an interface (``) that was promised by dialect 'func' but never implemented.", is interface nullptr? Something went wrong with registration before so there is no name? Certainly it should be possible to use, e.g., macro stringization to print at least the C++ class name of the missing interface.

I think https://reviews.llvm.org/D153676 should fix this:

LLVM ERROR: checking for an interface (`mlir::DialectInlinerInterface`) that was promised by dialect 'func' but never implemented. This is generally an indication that the dialect extension implementing the interface was never registered.

In D120368#4443907, @Hardcode84 wrote:

IMO, solution here causes more issues for users than the problem itself.

• I would prefer inliner pass to gracefully fail if extension wasn't registered instead of random abort with cryptic error message.

Feel free to suggest more improvement to the error message?
You can also try a patch to the inliner to check for the promise and fail gracefully.

• It DOES found legitimate problems (https://github.com/numba/numba-mlir/pull/145/files#diff-0e6154dff4e912fccd60d7837fe6bfe6c00e385619f26bd7f157e3720b833fb9R100) but they wasn't detected upstream as most users (including mlir-opt) will just register all extensions upfront. This defeats the entire purpose of this change.

I hit this while testing the registration problem Alex mentioned, and fixed it in 86e1c050e944
That said I don't quite get why you think it "defeats the entire purpose of this change": of course I'd like our upstream setup to be able to defend more against these dependent dialects issues, but this feature is entirely unrelated to this class of failures. The "promise" is intended prevent misconfiguration of the system with respect to external interfaces.

Right now I think what's still missing is enforcing that an interface was promised by a dialect to be allowed to be added externally.

[Hardcode84]

You can also try a patch to the inliner to check for the promise and fail gracefully.

No one asked for this feature, there weren't any PSA or public discussion (latest update in thread was more than a year ago), most users were just fine with status quo so reverting this is the easiest solution.

Right now I think what's still missing is enforcing that an interface was promised by a dialect to be allowed to be added externally.

Maybe revert and recommit after this is solved then?

Dependency between func and cf dialects may not be ideal, but at least it was enforced at compile time. To fix this minor annoyance you are introducing a whole new class of potential misconfigurations and runtime errors. Now, instead of (explicit and enforced) dependency between dialects, we will have an implicit dependency between pass and extension with no way to enforce it except in documentation (which doesn't exist, by the way).

[ftynse]

In D120368#4445875, @mehdi_amini wrote:

In D120368#4425402, @ftynse wrote:

Practically, promised dialects create a rather tight coupling between a dialect with a promised interface and an extension that realizes that promise.

Can you clarify where is the coupling between the dialect and the extension?

This makes the extension mandatory, which conceptually contradicts the notion of extension.

I don't quite get the contradiction: the intent here is that we promise that the extension will be available (when needed), without any coupling to the actual implementation. The provider is free to supply an extension however they wish.

Specifically, func dialect is now unusable without the extension that implements the inliner interface. I haven't had time to dig deeper into this, but it appears that it is the case even when the interface isn't ever requested by the user code.

I'd be interested in a test case, right now I can't reproduce.
I commented out registerAllExtensions() in mlir-opt.cpp, and re-run check-mlir:

My concern was due to seeing downstreams massively fail tests, which may be attribute those downstreams requesting an instance of DialectInlinerInterface outside of the actual inliner pass. I did not have time to investigate. It is unclear to me if the check for the implementation of the promised interface happens when the interface is first requested or before that. It appears that it's checked on request, so we shouldn't see non-inliner tests fail.

Arguably, having some sort of constructor finalization for MLIRContext that checks whether all promised interfaces were in fact provided would offer better usability than doing that on the first use, which may or may not happen. However, this contradicts my understanding of extensions: extensions provide additional features that aren't required for the "main" dialect to work. I suppose it's just word semantics though.

********************
Failed Tests (20):
  MLIR :: Conversion/AsyncToLLVM/convert-to-llvm.mlir
  MLIR :: Conversion/AsyncToLLVM/typed-pointers.mlir
  MLIR :: Dialect/Affine/inlining.mlir
  MLIR :: Dialect/Async/async-parallel-for-canonicalize.mlir
  MLIR :: Dialect/Async/async-parallel-for-compute-fn.mlir
  MLIR :: Dialect/Async/async-to-async-runtime.mlir
  MLIR :: Dialect/Bufferization/inlining.mlir
  MLIR :: Dialect/GPU/outlining.mlir
  MLIR :: Dialect/LLVMIR/inlining.mlir
  MLIR :: Dialect/Linalg/inlining.mlir
  MLIR :: Dialect/Tosa/inlining.mlir
  MLIR :: Examples/Toy/Ch5/affine-lowering.mlir
  MLIR :: Transforms/inlining-dce.mlir
  MLIR :: Transforms/inlining-recursive.mlir
  MLIR :: Transforms/inlining-repeated-use.mlir
  MLIR :: Transforms/inlining.mlir
  MLIR :: Transforms/test-inlining.mlir
  MLIR :: Transforms/test-legalizer-full.mlir
  MLIR :: Transforms/test-legalizer.mlir
  MLIR :: mlir-cpu-runner/async-group.mlir


Testing Time: 39.21s
  Unsupported:  265
  Passed     : 1872
  Failed     :   20

This seems consistent with the expected behavior I believe?

test-legalizer and affine-lowering look quite surprising to me here.

Furthermore, it is often impossible to register the extension as a dependency of the pass, beyond the need to do it manually rather than in .td of the pass declaration. Specifically, extension registration in multithreaded mode (even when the same extensions are present in the registry) triggers an assertion due to https://github.com/llvm/llvm-project/blob/bae2e56115d617cc5e152b4743484ab04649fe13/mlir/lib/IR/Dialect.cpp#L269-L271 and extensions not having a TypeID that could be used to deduplicate them. This happens for projects that create a pass manager inside a pass run by another pass manager. I would consider this practice dubious, but it is quite common.

The case you describe seems WAI if I understand correctly: the enclosing pass that is wrapping an inner pass-manager (not clear to me why it can't be replaced by the dynamic pipeline instead, but that's not changing the setup for this) should add it to the registry in the getDependentDialects() call.
I tried commenting out registerAllExtensions() in mlir-opt.cpp, and moving it to a getDependentDialects() in the InlinerPass:

void getDependentDialects(DialectRegistry &registry) const override {
  mlir::func::registerInlinerExtension(registry);
}

And ninja check-mlir is passing. Maybe I misunderstood what you're describing though?

MLIR doesn't seem to have a test where a new pass manager is constructed inside a pass that is being run by another pass manager. That would assert because it would attempt to register extensions while in multi-threaded mode because of the outer pass manager. I agree that this is a dubious setup, but it is quite widespread and not explicitly disallowed.

To complicate the matters, the error message omits the dialect name most of the time and reads like there it is itself buggy: "checking for an interface (``) that was promised by dialect 'func' but never implemented.", is interface nullptr? Something went wrong with registration before so there is no name? Certainly it should be possible to use, e.g., macro stringization to print at least the C++ class name of the missing interface.

I think https://reviews.llvm.org/D153676 should fix this:

LLVM ERROR: checking for an interface (`mlir::DialectInlinerInterface`) that was promised by dialect 'func' but never implemented. This is generally an indication that the dialect extension implementing the interface was never registered.

Thanks!

[mehdi_amini]

In D120368#4451867, @Hardcode84 wrote:

You can also try a patch to the inliner to check for the promise and fail gracefully.

No one asked for this feature, there weren't any PSA or public discussion (latest update in thread was more than a year ago), most users were just fine with status quo so reverting this is the easiest solution.

If by feature you're talking about "promised interface": then I asked for it when the concept of "external interface" was proposed: I would have made this a blocker had I know it'd take so long to get there: so no clearly this can't be a "solution".

If you're talking about using "promised interface" to break the dependency between func and cf, that's a different discussion, I have less opinions about the way to get there: I probably wouldn't have landed it in the same revision myself.

Right now I think what's still missing is enforcing that an interface was promised by a dialect to be allowed to be added externally.

Maybe revert and recommit after this is solved then?

How is it gonna help anything? This patch adds some checks, I'm saying we need more, but these aren't coupled: having these checks in isn't dependent in any way in having more checks.

Dependency between func and cf dialects may not be ideal, but at least it was enforced at compile time. To fix this minor annoyance you are introducing a whole new class of potential misconfigurations and runtime errors. Now, instead of (explicit and enforced) dependency between dialects, we will have an implicit dependency between pass and extension with no way to enforce it except in documentation (which doesn't exist, by the way).

There was not compile time enforcement before: misconfiguration would fail at runtime.
It's just that we hard-coded a dependency between dialects because they might be used in some configurations (combination of pass+dialect). If we didn't setup the dependency, it would just crash in worse way than that when the pass would be involved. The func dialect was only artificially depending on the cf dialect before.

test-legalizer and affine-lowering look quite surprising to me here.

Yeah these were just different cases of missing dependent dialect that this surfaced. Updated list:

Failed Tests (12):
  MLIR :: Dialect/Affine/inlining.mlir
  MLIR :: Dialect/Async/async-parallel-for-canonicalize.mlir
  MLIR :: Dialect/Async/async-parallel-for-compute-fn.mlir
  MLIR :: Dialect/Bufferization/inlining.mlir
  MLIR :: Dialect/LLVMIR/inlining.mlir
  MLIR :: Dialect/Linalg/inlining.mlir
  MLIR :: Dialect/Tosa/inlining.mlir
  MLIR :: Transforms/inlining-dce.mlir
  MLIR :: Transforms/inlining-recursive.mlir
  MLIR :: Transforms/inlining-repeated-use.mlir
  MLIR :: Transforms/inlining.mlir
  MLIR :: Transforms/test-inlining.mlir

MLIR doesn't seem to have a test where a new pass manager is constructed inside a pass that is being run by another pass manager. That would assert because it would attempt to register extensions while in multi-threaded mode because of the outer pass manager. I agree that this is a dubious setup, but it is quite widespread and not explicitly disallowed.

How is it different than dialect registration? Having a nested pass manager requires you to handle all registrations in getDependentDialects(), this is the case for as long as I can remember.
What changed is that the "support for inlining func.func" is now an extension whereas before we had this builtin in the func dialect initialization.

flang/include/flang/Optimizer/Support/InitFIR.h

 #ifndef FORTRAN_OPTIMIZER_SUPPORT_INITFIR_H
 #define FORTRAN_OPTIMIZER_SUPPORT_INITFIR_H
 
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/HLFIR/HLFIRDialect.h"
 #include "mlir/Conversion/Passes.h"
 #include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
+#include "mlir/Dialect/Func/Extensions/InlinerExtension.h"
 #include "mlir/InitAllDialects.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassRegistry.h"
 #include "mlir/Transforms/LocationSnapshot.h"
 #include "mlir/Transforms/Passes.h"
 
 namespace fir::support {
 
 #define FLANG_NONCODEGEN_DIALECT_LIST                                          \
   mlir::affine::AffineDialect, FIROpsDialect, hlfir::hlfirDialect,             \
       mlir::acc::OpenACCDialect, mlir::omp::OpenMPDialect,                     \
       mlir::scf::SCFDialect, mlir::arith::ArithDialect,                        \
       mlir::cf::ControlFlowDialect, mlir::func::FuncDialect,                   \
       mlir::vector::VectorDialect, mlir::math::MathDialect,                    \
       mlir::complex::ComplexDialect, mlir::DLTIDialect
 
+#define FLANG_CODEGEN_DIALECT_LIST FIRCodeGenDialect, mlir::LLVM::LLVMDialect
+
 // The definitive list of dialects used by flang.
 #define FLANG_DIALECT_LIST                                                     \
-  FLANG_NONCODEGEN_DIALECT_LIST, FIRCodeGenDialect, mlir::LLVM::LLVMDialect
+  FLANG_NONCODEGEN_DIALECT_LIST, FLANG_CODEGEN_DIALECT_LIST
 
 inline void registerNonCodegenDialects(mlir::DialectRegistry &registry) {
   registry.insert<FLANG_NONCODEGEN_DIALECT_LIST>();
+  mlir::func::registerInlinerExtension(registry);
 }
 
 /// Register all the dialects used by flang.
 inline void registerDialects(mlir::DialectRegistry &registry) {
-  registry.insert<FLANG_DIALECT_LIST>();
+  registerNonCodegenDialects(registry);
+  registry.insert<FLANG_CODEGEN_DIALECT_LIST>();
 }
 
 inline void loadNonCodegenDialects(mlir::MLIRContext &context) {
+  mlir::DialectRegistry registry;
+  registerNonCodegenDialects(registry);
+  context.appendDialectRegistry(registry);
+
   context.loadDialect<FLANG_NONCODEGEN_DIALECT_LIST>();
 }
 
 /// Forced load of all the dialects used by flang.  Lowering is not an MLIR
 /// pass, but a producer of FIR and MLIR. It is therefore a requirement that the
 /// dialects be preloaded to be able to build the IR.
 inline void loadDialects(mlir::MLIRContext &context) {
+  mlir::DialectRegistry registry;
+  registerDialects(registry);
+  context.appendDialectRegistry(registry);
+
   context.loadDialect<FLANG_DIALECT_LIST>();
 }
 
 /// Register the standard passes we use. This comes from registerAllPasses(),
 /// but is a smaller set since we aren't using many of the passes found there.
 inline void registerMLIRPassesForFortranTools() {
   mlir::registerCanonicalizerPass();
   mlir::registerCSEPass();

flang/lib/Frontend/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 
 add_flang_library(flangFrontend
   CompilerInstance.cpp
   CompilerInvocation.cpp
   CodeGenOptions.cpp
   FrontendAction.cpp
   FrontendActions.cpp
   FrontendOptions.cpp
   LangOptions.cpp
   TextDiagnosticPrinter.cpp
   TextDiagnosticBuffer.cpp
   TextDiagnostic.cpp
 
   DEPENDS
   FIRDialect
   FIROptTransformsPassIncGen
   HLFIRDialect
   MLIRIR
   ${dialect_libs}
+  ${extension_libs}
 
   LINK_LIBS
   FortranParser
   FortranSemantics
   FortranEvaluate
   FortranCommon
   FortranLower
   FIRDialect
   FIRDialectSupport
   FIRSupport
   FIRBuilder
   FIRCodeGen
   FIRTransforms
   HLFIRDialect
   HLFIRTransforms
   MLIRTransforms
   MLIRBuiltinToLLVMIRTranslation
   MLIRLLVMToLLVMIRTranslation
   MLIRSCFToControlFlow
   MLIRTargetLLVMIRImport
   ${dialect_libs}
+  ${extension_libs}
 
   LINK_COMPONENTS
   Passes
   Analysis
   Extensions
   IRReader
   Option
   Support

flang/lib/Lower/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 
 add_flang_library(FortranLower
   Allocatable.cpp
   Bridge.cpp
   CallInterface.cpp
   Coarray.cpp
   ConvertArrayConstructor.cpp
   ConvertCall.cpp
add_flang_library(FortranLower
   SymbolMap.cpp
   VectorSubscripts.cpp
   
   DEPENDS
   FIRDialect
   FIRTransforms
   HLFIRDialect
   ${dialect_libs}
+  ${extension_libs}
 
   LINK_LIBS
   FIRDialect
   FIRDialectSupport
   FIRBuilder
   FIRSupport
   FIRTransforms
   HLFIRDialect
   ${dialect_libs}
+  ${extension_libs}
   FortranCommon
   FortranParser
   FortranEvaluate
   FortranSemantics
   MLIRAffineToStandard
   MLIRFuncDialect
   MLIRLLVMDialect
   MLIRSCFToControlFlow
 
   LINK_COMPONENTS
   Support
 )

flang/lib/Optimizer/Builder/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 
 add_flang_library(FIRBuilder
   BoxValue.cpp
   Character.cpp
   Complex.cpp
   DoLoopHelper.cpp
   FIRBuilder.cpp
   HLFIRTools.cpp
add_flang_library(FIRBuilder
   Runtime/TemporaryStack.cpp
   Runtime/Transformational.cpp
   TemporaryStorage.cpp
 
   DEPENDS
   FIRDialect
   HLFIRDialect
   ${dialect_libs}
+  ${extension_libs}
 
   LINK_LIBS
   FIRDialect
   FIRDialectSupport
   FIRSupport
   HLFIRDialect
   ${dialect_libs}
+  ${extension_libs}
 )

flang/lib/Optimizer/Support/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 
 add_flang_library(FIRSupport
   InitFIR.cpp
   InternalNames.cpp
 
   DEPENDS
   FIROpsIncGen
   HLFIROpsIncGen
   MLIRIR
   ${dialect_libs}
+  ${extension_libs}
 
   LINK_LIBS
   ${dialect_libs}
+  ${extension_libs}
   MLIRBuiltinToLLVMIRTranslation
   MLIROpenACCToLLVMIRTranslation
   MLIROpenMPToLLVMIRTranslation
   MLIRLLVMToLLVMIRTranslation
   MLIRTargetLLVMIRExport
 
   LINK_COMPONENTS
   TargetParser
 )

flang/tools/bbc/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
 Passes
 TargetParser
 )
 
 add_flang_tool(bbc bbc.cpp
 DEPENDS
 FIROptCodeGenPassIncGen
 )
 
 llvm_update_compile_flags(bbc)
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 target_link_libraries(bbc PRIVATE
 FIRDialect
 FIRDialectSupport
 FIRSupport
 FIRTransforms
 FIRBuilder
 HLFIRDialect
 HLFIRTransforms
 ${dialect_libs}
+${extension_libs}
 MLIRAffineToStandard
 MLIRSCFToControlFlow
 FortranCommon
 FortranParser
 FortranEvaluate
 FortranSemantics
 FortranLower
 )

flang/tools/fir-opt/CMakeLists.txt

 add_flang_tool(fir-opt fir-opt.cpp)
 llvm_update_compile_flags(fir-opt)
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 
 if(FLANG_INCLUDE_TESTS)
   set(test_libs
     FIRTestAnalysis
     )
 endif()
 
 target_link_libraries(fir-opt PRIVATE
   FIRDialect
   FIRSupport
   FIRTransforms
   FIRCodeGen
   HLFIRDialect
   HLFIRTransforms
   FIRAnalysis
   ${test_libs}
   ${dialect_libs}
+  ${extension_libs}
 
   # TODO: these should be transitive dependencies from a target providing
   # "registerFIRPasses()"
   MLIRIR
   MLIRLLVMDialect
   MLIRPass
   MLIRFuncToLLVM
   MLIRTransforms

flang/tools/tco/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Passes
 )
 
 add_flang_tool(tco tco.cpp)
 llvm_update_compile_flags(tco)
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 target_link_libraries(tco PRIVATE
   FIRCodeGen
   FIRDialect
   FIRDialectSupport
   FIRSupport
   FIRTransforms
   FIRBuilder
   HLFIRDialect
   HLFIRTransforms
   ${dialect_libs}
+  ${extension_libs}
   MLIRIR
   MLIRLLVMDialect
   MLIRBuiltinToLLVMIRTranslation
   MLIRLLVMToLLVMIRTranslation
   MLIRTargetLLVMIRExport
   MLIRPass
-  MLIRFuncToLLVM
   MLIRTransforms
   MLIRAffineToStandard
   MLIRAnalysis
   MLIRSCFToControlFlow
   MLIRParser
   MLIRSupport
   MLIRVectorToLLVM
 )

flang/unittests/Optimizer/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 
 set(LIBS
   FIRBuilder
   FIRCodeGen
   FIRDialect
   FIRDialectSupport
   FIRSupport
   HLFIRDialect
   ${dialect_libs}
+  ${extension_libs}
   LLVMTargetParser
 )
 
 add_flang_unittest(FlangOptimizerTests
   Builder/CharacterTest.cpp
   Builder/ComplexTest.cpp
   Builder/DoLoopHelperTest.cpp
   Builder/FIRBuilderTest.cpp

mlir/cmake/modules/AddMLIR.cmake

 endfunction(add_mlir_dialect_library)
 
 # Declare the library associated with a conversion.
 function(add_mlir_conversion_library name)
   set_property(GLOBAL APPEND PROPERTY MLIR_CONVERSION_LIBS ${name})
   add_mlir_library(${ARGV} DEPENDS mlir-headers)
 endfunction(add_mlir_conversion_library)
 
+# Declare the library associated with an extension.
+function(add_mlir_extension_library name)
+  set_property(GLOBAL APPEND PROPERTY MLIR_EXTENSION_LIBS ${name})
+  add_mlir_library(${ARGV} DEPENDS mlir-headers)
+endfunction(add_mlir_extension_library)
+
 # Declare the library associated with a translation.
 function(add_mlir_translation_library name)
   set_property(GLOBAL APPEND PROPERTY MLIR_TRANSLATION_LIBS ${name})
   add_mlir_library(${ARGV} DEPENDS mlir-headers)
 endfunction(add_mlir_translation_library)
 
 # Verification tools to aid debugging.
 function(mlir_check_link_libraries name)

mlir/cmake/modules/CMakeLists.txt

 set(llvm_cmake_builddir "${llvm_cmake_builddir}/cmake/llvm")
 
 get_property(MLIR_EXPORTS GLOBAL PROPERTY MLIR_EXPORTS)
 export(TARGETS ${MLIR_EXPORTS} FILE ${mlir_cmake_builddir}/MLIRTargets.cmake)
 
 get_property(MLIR_ALL_LIBS GLOBAL PROPERTY MLIR_ALL_LIBS)
 get_property(MLIR_DIALECT_LIBS GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 get_property(MLIR_CONVERSION_LIBS GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
+get_property(MLIR_EXTENSION_LIBS GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 get_property(MLIR_TRANSLATION_LIBS GLOBAL PROPERTY MLIR_TRANSLATION_LIBS)
 
 # Generate MlirConfig.cmake for the build tree.
 set(MLIR_CONFIG_CMAKE_DIR "${mlir_cmake_builddir}")
 set(MLIR_CONFIG_LLVM_CMAKE_DIR "${llvm_cmake_builddir}")
 set(MLIR_CONFIG_INCLUDE_EXPORTS "include(\"\${MLIR_CMAKE_DIR}/MLIRTargets.cmake\")")
 set(MLIR_CONFIG_INCLUDE_DIRS
   "${MLIR_SOURCE_DIR}/include"

mlir/cmake/modules/MLIRConfig.cmake.in

 
 # For mlir_tablegen()
 set(MLIR_INCLUDE_DIR "@MLIR_INCLUDE_DIR@")
 set(MLIR_MAIN_SRC_DIR "@MLIR_MAIN_SRC_DIR@")
 
 set_property(GLOBAL PROPERTY MLIR_ALL_LIBS "@MLIR_ALL_LIBS@")
 set_property(GLOBAL PROPERTY MLIR_DIALECT_LIBS "@MLIR_DIALECT_LIBS@")
 set_property(GLOBAL PROPERTY MLIR_CONVERSION_LIBS "@MLIR_CONVERSION_LIBS@")
+set_property(GLOBAL PROPERTY MLIR_EXTENSION_LIBS "@MLIR_EXTENSION_LIBS@")
 set_property(GLOBAL PROPERTY MLIR_TRANSLATION_LIBS "@MLIR_TRANSLATION_LIBS@")
 
 # Provide all our library targets to users.
 # More specifically, configure MLIR so that it can be directly included in a top
 # level CMakeLists.txt, but also so that it can be imported via `find_package`.
 # This is based on how LLVM handles exports.
 if(NOT TARGET MLIRSupport)
   @MLIR_CONFIG_INCLUDE_EXPORTS@

mlir/examples/toy/Ch5/CMakeLists.txt

add_toy_chapter(toyc-ch5
   ToyCh5ShapeInferenceInterfaceIncGen
   ToyCh5OpsIncGen
   ToyCh5CombineIncGen
   )
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/include/)
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 target_link_libraries(toyc-ch5
   PRIVATE
     ${dialect_libs}
+    ${extension_libs}
     MLIRAnalysis
     MLIRCallInterfaces
     MLIRCastInterfaces
     MLIRIR
     MLIRParser
     MLIRPass
     MLIRSideEffectInterfaces
     MLIRSupport
     MLIRTransforms)

mlir/examples/toy/Ch5/toyc.cpp

 //===- toyc.cpp - The Toy Compiler ----------------------------------------===//
 //
 // 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 implements the entry point for the Toy compiler.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Dialect/Func/Extensions/AllExtensions.h"
 #include "toy/Dialect.h"
 #include "toy/MLIRGen.h"
 #include "toy/Parser.h"
 #include "toy/Passes.h"
 
 #include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/IR/AsmState.h"
 #include "mlir/IR/BuiltinOps.h"
int loadMLIR(llvm::SourceMgr &sourceMgr, mlir::MLIRContext &context,
   if (!module) {
     llvm::errs() << "Error can't load file " << inputFilename << "\n";
     return 3;
   }
   return 0;
 }
 
 int dumpMLIR() {
-  mlir::MLIRContext context;
+  mlir::DialectRegistry registry;
+  mlir::func::registerAllExtensions(registry);
+
+  mlir::MLIRContext context(registry);
   // Load our Dialect in this MLIR Context.
   context.getOrLoadDialect<mlir::toy::ToyDialect>();
 
   mlir::OwningOpRef<mlir::ModuleOp> module;
   llvm::SourceMgr sourceMgr;
   mlir::SourceMgrDiagnosticHandler sourceMgrHandler(sourceMgr, &context);
   if (int error = loadMLIR(sourceMgr, context, module))
     return error;

mlir/examples/toy/Ch6/CMakeLists.txt

add_toy_chapter(toyc-ch6
   ToyCh6OpsIncGen
   ToyCh6CombineIncGen
   )
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/include/)
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
+get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 target_link_libraries(toyc-ch6
   PRIVATE
     ${dialect_libs}
     ${conversion_libs}
+    ${extension_libs}
     MLIRAnalysis
     MLIRBuiltinToLLVMIRTranslation
     MLIRCallInterfaces
     MLIRCastInterfaces
     MLIRExecutionEngine
     MLIRIR
     MLIRLLVMCommonConversion
     MLIRLLVMDialect

mlir/examples/toy/Ch6/toyc.cpp

 //===- toyc.cpp - The Toy Compiler ----------------------------------------===//
 //
 // 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 implements the entry point for the Toy compiler.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Dialect/Func/Extensions/AllExtensions.h"
 #include "toy/Dialect.h"
 #include "toy/MLIRGen.h"
 #include "toy/Parser.h"
 #include "toy/Passes.h"
 
 #include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/LLVMIR/Transforms/Passes.h"
 #include "mlir/ExecutionEngine/ExecutionEngine.h"
int main(int argc, char **argv) {
   mlir::registerPassManagerCLOptions();
 
   cl::ParseCommandLineOptions(argc, argv, "toy compiler\n");
 
   if (emitAction == Action::DumpAST)
     return dumpAST();
 
   // If we aren't dumping the AST, then we are compiling with/to MLIR.
+  mlir::DialectRegistry registry;
+  mlir::func::registerAllExtensions(registry);
 
-  mlir::MLIRContext context;
+  mlir::MLIRContext context(registry);
   // Load our Dialect in this MLIR Context.
   context.getOrLoadDialect<mlir::toy::ToyDialect>();
 
   mlir::OwningOpRef<mlir::ModuleOp> module;
   if (int error = loadAndProcessMLIR(context, module))
     return error;
 
   // If we aren't exporting to non-mlir, then we are done.

mlir/examples/toy/Ch7/CMakeLists.txt

add_toy_chapter(toyc-ch7
   ToyCh7OpsIncGen
   ToyCh7CombineIncGen
   )
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/include/)
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
+get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 target_link_libraries(toyc-ch7
   PRIVATE
     ${dialect_libs}
     ${conversion_libs}
+    ${extension_libs}
     MLIRAnalysis
     MLIRBuiltinToLLVMIRTranslation
     MLIRCallInterfaces
     MLIRCastInterfaces
     MLIRExecutionEngine
     MLIRIR
     MLIRLLVMCommonConversion
     MLIRLLVMToLLVMIRTranslation
     MLIRMemRefDialect
     MLIRParser
     MLIRPass
     MLIRSideEffectInterfaces
     MLIRTargetLLVMIRExport
     MLIRTransforms
     )

mlir/examples/toy/Ch7/toyc.cpp

 //===- toyc.cpp - The Toy Compiler ----------------------------------------===//
 //
 // 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 implements the entry point for the Toy compiler.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Dialect/Func/Extensions/AllExtensions.h"
 #include "toy/Dialect.h"
 #include "toy/MLIRGen.h"
 #include "toy/Parser.h"
 #include "toy/Passes.h"
 
 #include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/LLVMIR/Transforms/Passes.h"
 #include "mlir/ExecutionEngine/ExecutionEngine.h"
int main(int argc, char **argv) {
   mlir::registerPassManagerCLOptions();
 
   cl::ParseCommandLineOptions(argc, argv, "toy compiler\n");
 
   if (emitAction == Action::DumpAST)
     return dumpAST();
 
   // If we aren't dumping the AST, then we are compiling with/to MLIR.
+  mlir::DialectRegistry registry;
+  mlir::func::registerAllExtensions(registry);
 
-  mlir::MLIRContext context;
+  mlir::MLIRContext context(registry);
   // Load our Dialect in this MLIR Context.
   context.getOrLoadDialect<mlir::toy::ToyDialect>();
 
   mlir::OwningOpRef<mlir::ModuleOp> module;
   if (int error = loadAndProcessMLIR(context, module))
     return error;
 
   // If we aren't exporting to non-mlir, then we are done.

mlir/include/mlir/Dialect/Func/Extensions/AllExtensions.h

+//===- AllExtensions.h - All Func Extensions --------------------*- 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 defines a common entry point for registering all extensions to the
+// func dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_FUNC_EXTENSIONS_ALLEXTENSIONS_H
+#define MLIR_DIALECT_FUNC_EXTENSIONS_ALLEXTENSIONS_H
+
+namespace mlir {
+class DialectRegistry;
+
+namespace func {
+/// Register all extensions of the func dialect. This should generally only be
+/// used by tools, or other use cases that really do want *all* extensions of
+/// the dialect. All other cases should prefer to instead register the specific
+/// extensions they intend to take advantage of.
+void registerAllExtensions(DialectRegistry &registry);
+} // namespace func
+
+} // namespace mlir
+
+#endif // MLIR_DIALECT_FUNC_EXTENSIONS_ALLEXTENSIONS_H

mlir/include/mlir/Dialect/Func/Extensions/InlinerExtension.h

+//===- InlinerExtension.h - Func Inliner Extension 0000----------*- 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 defines an extension for the func dialect that implements the
+// interfaces necessary to support inlining.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_FUNC_EXTENSIONS_INLINEREXTENSION_H
+#define MLIR_DIALECT_FUNC_EXTENSIONS_INLINEREXTENSION_H
+
+namespace mlir {
+class DialectRegistry;
+
+namespace func {
+/// Register the extension used to support inlining the func dialect.
+void registerInlinerExtension(DialectRegistry &registry);
+} // namespace func
+
+} // namespace mlir
+
+#endif // MLIR_DIALECT_FUNC_EXTENSIONS_INLINEREXTENSION_H

mlir/include/mlir/Dialect/Func/IR/FuncOps.td

 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/IR/FunctionInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def Func_Dialect : Dialect {
   let name = "func";
   let cppNamespace = "::mlir::func";
-  let dependentDialects = ["cf::ControlFlowDialect"];
   let hasConstantMaterializer = 1;
   let usePropertiesForAttributes = 1;
 }
 
 // Base class for Func dialect ops.
 class Func_Op<string mnemonic, list<Trait> traits = []> :
     Op<Func_Dialect, mnemonic, traits>;
 

mlir/include/mlir/IR/Attributes.h

public:
   using Base = AttributeInterface<ConcreteType, Traits>;
   using InterfaceBase = detail::Interface<ConcreteType, Attribute, Traits,
                                           Attribute, AttributeTrait::TraitBase>;
   using InterfaceBase::InterfaceBase;
 
 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(),
+        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);
+#endif
+
     auto it = registeredInterfaces.find(interfaceID);
     return it != registeredInterfaces.end() ? it->getSecond().get() : nullptr;
   }
   template <typename InterfaceT>
   InterfaceT *getRegisteredInterface() {
+#ifndef NDEBUG
+    handleUseOfUndefinedPromisedInterface(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
   /// nullptr.
   virtual void *getRegisteredInterfaceForOp(TypeID interfaceID,
                                             OperationName opName) {
#endif
   }
   template <typename InterfaceT, typename... Args>
   InterfaceT &addInterface(Args &&...args) {
     InterfaceT *interface = new InterfaceT(this, std::forward<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>
+  void declarePromisedInterface() {
+    unresolvedPromisedInterfaces.insert(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,
+                                             StringRef interfaceName = "") {
+    if (unresolvedPromisedInterfaces.count(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);
+  }
+
 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 '.'.
   /// Example:
   ///       - "tf" for the TensorFlow ops like "tf.add".
private:
   /// Flag that specifies whether this dialect allows unregistered types, i.e.
   /// types prefixed with the dialect namespace but not registered with addType.
   /// These types are represented with OpaqueType.
   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;
+
   friend class DialectRegistry;
   friend void registerDialect();
   friend class MLIRContext;
 };
 
 } // namespace mlir
 
 namespace llvm {

mlir/include/mlir/IR/DialectRegistry.h

void apply(MLIRContext *context,
     unsigned dialectIdx = 0;
     auto derivedDialects = std::tuple<DialectsT *...>{
         static_cast<DialectsT *>(dialects[dialectIdx++])...};
     std::apply([&](DialectsT *...dialect) { apply(context, dialect...); },
                derivedDialects);
   }
 };
 
+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,
+                                           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 interfaceID);
+
+} // 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
 /// "available" from the dialects loaded in the Context. The parser in
 /// particular will lazily load dialects in the Context as operations are

mlir/include/mlir/IR/OpDefinition.h

public:
   /// Inherit the base class constructor.
   using InterfaceBase::InterfaceBase;
 
 protected:
   /// Returns the impl interface instance for the given operation.
   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(),
+          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>())
         return opIface;
       // Fallback to the dialect to provide it with a chance to implement this
       // interface for this operation.
       return rInfo->getDialect().getRegisteredInterfaceForOp<ConcreteType>(

mlir/include/mlir/IR/OperationSupport.h

 
 #ifndef MLIR_IR_OPERATIONSUPPORT_H
 #define MLIR_IR_OPERATIONSUPPORT_H
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BlockSupport.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/Diagnostics.h"
+#include "mlir/IR/DialectRegistry.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/TypeRange.h"
 #include "mlir/IR/Types.h"
 #include "mlir/IR/Value.h"
 #include "mlir/Support/InterfaceSupport.h"
 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
public:
   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() {
+    // Handle the case where the models resolve a promised interface.
+    (dialect_extension_detail::handleAdditionOfUndefinedPromisedInterface(
+         *getDialect(), Models::Interface::getInterfaceID()),
+     ...);
+
     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>());
   }

mlir/include/mlir/IR/StorageUniquerSupport.h

 //===- StorageUniquerSupport.h - MLIR Storage Uniquer Utilities -*- 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 defines utility classes for interfacing with StorageUniquer.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_STORAGEUNIQUERSUPPORT_H
 #define MLIR_IR_STORAGEUNIQUERSUPPORT_H
 
 #include "mlir/IR/AttrTypeSubElements.h"
+#include "mlir/IR/DialectRegistry.h"
 #include "mlir/Support/InterfaceSupport.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Support/StorageUniquer.h"
 #include "mlir/Support/TypeID.h"
 #include "llvm/ADT/FunctionExtras.h"
 
 namespace mlir {
 class InFlightDiagnostic;
public:
   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.");
 
+    // Handle the case where the models resolve a promised interface.
+    (dialect_extension_detail::handleAdditionOfUndefinedPromisedInterface(
+         abstract->getDialect(), 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
   /// the arguments provided are invalid.
   template <typename... Args>

mlir/include/mlir/IR/Types.h

public:
   using Base = TypeInterface<ConcreteType, Traits>;
   using InterfaceBase =
       detail::Interface<ConcreteType, Type, Traits, Type, TypeTrait::TraitBase>;
   using InterfaceBase::InterfaceBase;
 
 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(),
+        llvm::getTypeName<ConcreteType>());
+#endif
+
     return type.getAbstractType().getInterface<ConcreteType>();
   }
 
   /// Allow access to 'getInterfaceFor'.
   friend InterfaceBase;
 };
 
 //===----------------------------------------------------------------------===//

mlir/include/mlir/InitAllExtensions.h

+//===- InitAllExtensions.h - MLIR Extension Registration --------*- 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 defines a helper to trigger the registration of all dialect
+// extensions to the system.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_INITALLEXTENSIONS_H_
+#define MLIR_INITALLEXTENSIONS_H_
+
+#include "mlir/Dialect/Func/Extensions/AllExtensions.h"
+
+#include <cstdlib>
+
+namespace mlir {
+
+/// This function may be called to register all MLIR dialect extensions with the
+/// provided registry.
+/// If you're building a compiler, you generally shouldn't use this: you would
+/// individually register the specific extensions that are useful for the
+/// pipelines and transformations you are using.
+inline void registerAllExtensions(DialectRegistry &registry) {
+  func::registerAllExtensions(registry);
+}
+
+} // namespace mlir
+
+#endif // MLIR_INITALLEXTENSIONS_H_

mlir/lib/Dialect/Func/CMakeLists.txt

+add_subdirectory(Extensions)
 add_subdirectory(IR)
 add_subdirectory(Transforms)

mlir/lib/Dialect/Func/Extensions/AllExtensions.cpp

+//===- AllExtensions.cpp - All Func Dialect Extensions --------------------===//
+//
+// 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/Dialect/Func/Extensions/AllExtensions.h"
+#include "mlir/Dialect/Func/Extensions/InlinerExtension.h"
+
+using namespace mlir;
+
+void mlir::func::registerAllExtensions(DialectRegistry &registry) {
+  registerInlinerExtension(registry);
+}

mlir/lib/Dialect/Func/Extensions/CMakeLists.txt

+set(LLVM_OPTIONAL_SOURCES
+  AllExtensions.cpp
+  InlinerExtension.cpp
+  )
+
+add_mlir_extension_library(MLIRFuncInlinerExtension
+  InlinerExtension.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Func/Extensions
+
+  LINK_LIBS PUBLIC
+  MLIRControlFlowDialect
+  MLIRInferTypeOpInterface
+  MLIRIR
+  MLIRFuncDialect
+  )
+
+add_mlir_extension_library(MLIRFuncAllExtensions
+  AllExtensions.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Func/Extensions
+
+  LINK_LIBS PUBLIC
+  MLIRFuncInlinerExtension
+  )

mlir/lib/Dialect/Func/Extensions/InlinerExtension.cpp

+//===- InlinerExtension.cpp - Func Inliner Extension ----------------------===//
+//
+// 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/Dialect/Func/Extensions/InlinerExtension.h"
+#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/IR/DialectInterface.h"
+#include "mlir/Transforms/InliningUtils.h"
+
+using namespace mlir;
+using namespace mlir::func;
+
+//===----------------------------------------------------------------------===//
+// FuncDialect Interfaces
+//===----------------------------------------------------------------------===//
+namespace {
+/// This class defines the interface for handling inlining with func operations.
+struct FuncInlinerInterface : public DialectInlinerInterface {
+  using DialectInlinerInterface::DialectInlinerInterface;
+
+  //===--------------------------------------------------------------------===//
+  // Analysis Hooks
+  //===--------------------------------------------------------------------===//
+
+  /// All call operations can be inlined.
+  bool isLegalToInline(Operation *call, Operation *callable,
+                       bool wouldBeCloned) const final {
+    return true;
+  }
+
+  /// All operations can be inlined.
+  bool isLegalToInline(Operation *, Region *, bool, IRMapping &) const final {
+    return true;
+  }
+
+  /// All functions can be inlined.
+  bool isLegalToInline(Region *, Region *, bool, IRMapping &) const final {
+    return true;
+  }
+
+  //===--------------------------------------------------------------------===//
+  // Transformation Hooks
+  //===--------------------------------------------------------------------===//
+
+  /// Handle the given inlined terminator by replacing it with a new operation
+  /// as necessary.
+  void handleTerminator(Operation *op, Block *newDest) const final {
+    // Only return needs to be handled here.
+    auto returnOp = dyn_cast<ReturnOp>(op);
+    if (!returnOp)
+      return;
+
+    // Replace the return with a branch to the dest.
+    OpBuilder builder(op);
+    builder.create<cf::BranchOp>(op->getLoc(), newDest, returnOp.getOperands());
+    op->erase();
+  }
+
+  /// Handle the given inlined terminator by replacing it with a new operation
+  /// as necessary.
+  void handleTerminator(Operation *op,
+                        ArrayRef<Value> valuesToRepl) const final {
+    // Only return needs to be handled here.
+    auto returnOp = cast<ReturnOp>(op);
+
+    // Replace the values directly with the return operands.
+    assert(returnOp.getNumOperands() == valuesToRepl.size());
+    for (const auto &it : llvm::enumerate(returnOp.getOperands()))
+      valuesToRepl[it.index()].replaceAllUsesWith(it.value());
+  }
+};
+} // namespace
+
+//===----------------------------------------------------------------------===//
+// Registration
+//===----------------------------------------------------------------------===//
+
+void mlir::func::registerInlinerExtension(DialectRegistry &registry) {
+  registry.addExtension(+[](MLIRContext *ctx, func::FuncDialect *dialect) {
+    dialect->addInterfaces<FuncInlinerInterface>();
+
+    // The inliner extension relies on the ControlFlow dialect.
+    ctx->getOrLoadDialect<cf::ControlFlowDialect>();
+  });
+}

mlir/lib/Dialect/Func/IR/CMakeLists.txt

 add_mlir_dialect_library(MLIRFuncDialect
   FuncOps.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Func
 
   DEPENDS
   MLIRFuncOpsIncGen
 
   LINK_LIBS PUBLIC
   MLIRCallInterfaces
-  MLIRControlFlowDialect
   MLIRControlFlowInterfaces
   MLIRInferTypeOpInterface
   MLIRIR
   MLIRSideEffectInterfaces
   )

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

 //===- FuncOps.cpp - Func Dialect Operations ------------------------------===//
 //
 // 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/Dialect/Func/IR/FuncOps.h"
 
-#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
-#include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/IRMapping.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/IR/Value.h"
 #include "mlir/Support/MathExtras.h"
 #include "mlir/Transforms/InliningUtils.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
 #include <numeric>
 
 #include "mlir/Dialect/Func/IR/FuncOpsDialect.cpp.inc"
 
 using namespace mlir;
 using namespace mlir::func;
 
 //===----------------------------------------------------------------------===//
-// FuncDialect Interfaces
-//===----------------------------------------------------------------------===//
-namespace {
-/// This class defines the interface for handling inlining with func operations.
-struct FuncInlinerInterface : public DialectInlinerInterface {
-  using DialectInlinerInterface::DialectInlinerInterface;
-
-  //===--------------------------------------------------------------------===//
-  // Analysis Hooks
-  //===--------------------------------------------------------------------===//
-
-  /// All call operations can be inlined.
-  bool isLegalToInline(Operation *call, Operation *callable,
-                       bool wouldBeCloned) const final {
-    return true;
-  }
-
-  /// All operations can be inlined.
-  bool isLegalToInline(Operation *, Region *, bool, IRMapping &) const final {
-    return true;
-  }
-
-  /// All functions can be inlined.
-  bool isLegalToInline(Region *, Region *, bool, IRMapping &) const final {
-    return true;
-  }
-
-  //===--------------------------------------------------------------------===//
-  // Transformation Hooks
-  //===--------------------------------------------------------------------===//
-
-  /// Handle the given inlined terminator by replacing it with a new operation
-  /// as necessary.
-  void handleTerminator(Operation *op, Block *newDest) const final {
-    // Only return needs to be handled here.
-    auto returnOp = dyn_cast<ReturnOp>(op);
-    if (!returnOp)
-      return;
-
-    // Replace the return with a branch to the dest.
-    OpBuilder builder(op);
-    builder.create<cf::BranchOp>(op->getLoc(), newDest, returnOp.getOperands());
-    op->erase();
-  }
-
-  /// Handle the given inlined terminator by replacing it with a new operation
-  /// as necessary.
-  void handleTerminator(Operation *op,
-                        ArrayRef<Value> valuesToRepl) const final {
-    // Only return needs to be handled here.
-    auto returnOp = cast<ReturnOp>(op);
-
-    // Replace the values directly with the return operands.
-    assert(returnOp.getNumOperands() == valuesToRepl.size());
-    for (const auto &it : llvm::enumerate(returnOp.getOperands()))
-      valuesToRepl[it.index()].replaceAllUsesWith(it.value());
-  }
-};
-} // namespace
-
-//===----------------------------------------------------------------------===//
 // FuncDialect
 //===----------------------------------------------------------------------===//
 
 void FuncDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Func/IR/FuncOps.cpp.inc"
       >();
-  addInterfaces<FuncInlinerInterface>();
+  declarePromisedInterface<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/IR/Dialect.cpp

 /// namespace
 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());
+
   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 "
                    << getNamespace();

 }
 
 //===----------------------------------------------------------------------===//
 // DialectExtension
 //===----------------------------------------------------------------------===//
 
 DialectExtensionBase::~DialectExtensionBase() = default;
 
+void dialect_extension_detail::handleUseOfUndefinedPromisedInterface(
+    Dialect &dialect, TypeID interfaceID, StringRef interfaceName) {
+  dialect.handleUseOfUndefinedPromisedInterface(interfaceID, interfaceName);
+}
+
+void dialect_extension_detail::handleAdditionOfUndefinedPromisedInterface(
+    Dialect &dialect, TypeID interfaceID) {
+  dialect.handleAdditionOfUndefinedPromisedInterface(interfaceID);
+}
+
 //===----------------------------------------------------------------------===//
 // DialectRegistry
 //===----------------------------------------------------------------------===//
 
 DialectRegistry::DialectRegistry() { insert<BuiltinDialect>(); }
 
 DialectAllocatorFunctionRef
 DialectRegistry::getDialectAllocator(StringRef name) const {

mlir/test/CAPI/ir.c

int registerOnlyStd(void) {
   MlirStringRef alsoStdNs = mlirDialectHandleGetNamespace(stdHandle);
   if (stdNs.length != alsoStdNs.length ||
       strncmp(stdNs.data, alsoStdNs.data, stdNs.length))
     return 5;
 
   fprintf(stderr, "@registration\n");
   // CHECK-LABEL: @registration
 
-  // CHECK: cf.cond_br is_registered: 1
-  fprintf(stderr, "cf.cond_br is_registered: %d\n",
+  // CHECK: func.call is_registered: 1
+  fprintf(stderr, "func.call is_registered: %d\n",
           mlirContextIsRegisteredOperation(
-              ctx, mlirStringRefCreateFromCString("cf.cond_br")));
+              ctx, mlirStringRefCreateFromCString("func.call")));
 
   // CHECK: func.not_existing_op is_registered: 0
   fprintf(stderr, "func.not_existing_op is_registered: %d\n",
           mlirContextIsRegisteredOperation(
               ctx, mlirStringRefCreateFromCString("func.not_existing_op")));
 
   // CHECK: not_existing_dialect.not_existing_op is_registered: 0
   fprintf(stderr, "not_existing_dialect.not_existing_op is_registered: %d\n",

 int testClone(void) {
   fprintf(stderr, "@testClone\n");
   // CHECK-LABEL: @testClone
 
   MlirContext ctx = mlirContextCreate();
   registerAllUpstreamDialects(ctx);
 
   mlirContextGetOrLoadDialect(ctx, mlirStringRefCreateFromCString("func"));
+  mlirContextGetOrLoadDialect(ctx, mlirStringRefCreateFromCString("arith"));
   MlirLocation loc = mlirLocationUnknownGet(ctx);
   MlirType indexType = mlirIndexTypeGet(ctx);
   MlirStringRef valueStringRef = mlirStringRefCreateFromCString("value");
 
   MlirAttribute indexZeroLiteral =
       mlirAttributeParseGet(ctx, mlirStringRefCreateFromCString("0 : index"));
   MlirNamedAttribute indexZeroValueAttr = mlirNamedAttributeGet(
       mlirIdentifierGet(ctx, valueStringRef), indexZeroLiteral);

mlir/tools/mlir-opt/CMakeLists.txt

 set(LLVM_OPTIONAL_SOURCES
   null.cpp
 )
 
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
+get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 set(LLVM_LINK_COMPONENTS
   Core
   Support
   AsmParser
   )
 
 if(MLIR_INCLUDE_TESTS)
   set(test_libs
set(test_libs
     MLIRTestVectorToSPIRV
     MLIRLLVMTestPasses
     )
 endif()
 
 set(LIBS
   ${dialect_libs}
   ${conversion_libs}
+  ${extension_libs}
   ${test_libs}
+
   MLIRAffineAnalysis
   MLIRAnalysis
   MLIRCastInterfaces
   MLIRDialect
   MLIROptLib
   MLIRParser
   MLIRPass
   MLIRTransforms

mlir/tools/mlir-opt/mlir-opt.cpp

 //===- mlir-opt.cpp - MLIR Optimizer Driver -------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Main entry function for mlir-opt for when built as standalone binary.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/AsmState.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/InitAllDialects.h"
+#include "mlir/InitAllExtensions.h"
 #include "mlir/InitAllPasses.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Support/FileUtilities.h"
 #include "mlir/Tools/mlir-opt/MlirOptMain.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/SourceMgr.h"

 
 int main(int argc, char **argv) {
   registerAllPasses();
 #ifdef MLIR_INCLUDE_TESTS
   registerTestPasses();
 #endif
   DialectRegistry registry;
   registerAllDialects(registry);
+  registerAllExtensions(registry);
+
 #ifdef MLIR_INCLUDE_TESTS
   ::test::registerTestDialect(registry);
   ::test::registerTestTransformDialectExtension(registry);
   ::test::registerTestDynDialect(registry);
 #endif
   return mlir::asMainReturnCode(
       mlir::MlirOptMain(argc, argv, "MLIR modular optimizer driver\n", registry));
 }

mlir/unittests/Interfaces/CMakeLists.txt

 add_mlir_unittest(MLIRInterfacesTests
   ControlFlowInterfacesTest.cpp
   DataLayoutInterfacesTest.cpp
   InferIntRangeInterfaceTest.cpp
   InferTypeOpInterfaceTest.cpp
 )
 
 target_link_libraries(MLIRInterfacesTests
   PRIVATE
+  MLIRArithDialect
   MLIRControlFlowInterfaces
   MLIRDataLayoutInterfaces
   MLIRDLTIDialect
   MLIRFuncDialect
   MLIRInferIntRangeInterface
   MLIRInferTypeOpInterface
   MLIRParser
 )