[mlir] Add extensible dialects

[math-fehr]

Summary

Depends on D104534
Add support for extensible dialects, which are dialects that can be
extended at runtime with new operations and types.

These operations and types cannot at the moment implement traits
or interfaces.

[math-fehr]

Remove use of std::vector in favor of SmallVector

[math-fehr]

Add new useful methods on ExtensibleDialect.
Also, fix cast on ExtensibleDialect.

[math-fehr]

Fix include guard name and use const_cast instead of an API change

[math-fehr]

Return nullptr instead of a FailureOr in lookupTypeDefinition

[rriddle]

Sorry for the delay!

Can you write up a doc (in the docs/ folder) detailing everything here? It would make it easier to understand the design, how it is intended to be used, etc.

mlir/include/mlir/IR/IsDynamicInterfaces.td

19–23 ↗

(On Diff #353668)

This could just be a trait? Is there a specific reason you need an interface?

[math-fehr]

In D104554#2844903, @rriddle wrote:

Sorry for the delay!

Can you write up a doc (in the docs/ folder) detailing everything here? It would make it easier to understand the design, how it is intended to be used, etc.

No problem!
I'll write something this week.

mlir/include/mlir/IR/IsDynamicInterfaces.td

19–23 ↗

(On Diff #353668)

Yes, a trait would work.
However, it seems that MLIR does not really support type traits. I found a TypeTrait class, but no hasTrait function on the Type class, nor ways to define type traits in ODS.
Is there anything I missed, or maybe a patch is needed to implement them?

[rriddle]

mlir/include/mlir/IR/IsDynamicInterfaces.td

19–23 ↗

(On Diff #353668)

We just need a patch to implement the remaining accessors (interfaces use traits internally). Do you want to prepare a patch for that? It would be very welcome.

[math-fehr]

mlir/include/mlir/IR/IsDynamicInterfaces.td

19–23 ↗

(On Diff #353668)

Sure! I'll write a patch to add that.

[math-fehr]

Fix memory error by allocating the dialect name in the MLIRContext.

[math-fehr]

Add a file in docs/ documenting the patch

Sorry for the delay!

[rriddle]

mlir/docs/ExtensibleDialects.md

6–7

13

16

18–19

37–38

50–53

97–107

It feels like DynamicOpDefinition::get should not be accessible, and instead just an implementation detail of an overload to addDynamicOperation. Is there a benefit to not having this API directly on ExtensibleDialect?

109–110

If you did the above, you wouldn't need this at all. It would be guaranteed on construction.

135–136

Why?

169–171

Same comment here as operations.

225

Can you add a section/support for attributes?

[math-fehr]

Sorry for the delay!

I responded to two inline comments about the design choices.
I'll fix the other comments once I have some time!

mlir/docs/ExtensibleDialects.md

97–107

So there are two problems here:

• One, we have many optional fields (such as the printer, parser, fold hook function, and the canonicalization patterns). I thought that having a builder pattern would be better, but it seems indeed that having multiple overloaded functions that would solve most cases would be best if this was only the problem.
• The main problem is that I think we want to allow cyclic dependencies between the operation definitions. For instance, an op A and B could both refer to the other op in their verifiers. In order to do that efficiently, we need that A knows the TypeID of B, and vice-versa. This can be done with DynamicOpDefinition, since it already allocated the TypeID.

Do you think that this makes sense?

135–136

Attributes and Types in MLIR are defined with C++ classes to hold arbitrary data.
However, to represent types (and attributes) defined at runtime, we need a unified way that would allow to hold arbitrary data.
One solution is to represent parameters of types defined at runtime by an array of Attribute. This let us hold arbitrary data (given that the corresponding Attribute is already defined).
I don't have any other solution for this problem, what are your thoughts?

[math-fehr]

• Add attributes support
• Fix grammar and spelling in the documentation
• Change the type and attribute interfaces to traits

[math-fehr]

All comments should be addressed now, besides two where I answered in the comments.

[math-fehr]

Hey @rriddle, a gentle ping on this.

[rriddle]

Took another scan, thanks for the ping!

mlir/docs/ExtensibleDialects.md

97–107

I see, so we would construct a bunch of dynamic operations up front and then register them later? Do we have any asserts that we actually add the dynamic operation to the dialect? (i.e. if we didn't call addDynamicOperation)

135–136

I was considering if it would be better if we had an abstract interface for this data, that would not require them to be stored/represented in attributes. E.g. If I wanted to store some random swift/python/rust/etc. value, how would it be stored? is it required to be some form of pointer handle? Thinking about if the bindings for those languages don't force pointer handles, it might be more annoying to force going through an attribute.

mlir/include/mlir/IR/ExtensibleDialect.h

54–55

Can you document this method? And how it should be used.

55

nit: Drop all of the llvm:: from StringRef uses, StringRef is exported in the mlir namespace.

mlir/lib/IR/ExtensibleDialect.cpp

25–30

Please mark these as static and place at the top level, only classes should really go in anonymous namespaces.

29

nit: Drop the llvm:: here.

68–74

Can you just forward to the other ::get instead?

177–180

You should be able to call parser.getChecked<DynamicType>(typeDef, params) now.

This also seems to ignore the result of getChecked, what happens if it fails?

196–202

Same comment here as DynamicTypeDefinition.

305–310

Same comment here as DynamicTypeDefinition.

342–345

360–363

nit: Drop mlir:: and llvm:: here.

395–398

This should be in an anonymous namespace.

480–481

Can you spell out auto here? and also flip to use early exit?

if (!typeDef)

return llvm::None;

486

?

503–505

Same comment here as Type.

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

144–147

nit: Use static methods at the top-level instead of anonymous namespaces.

258

Prefer llvm_unreachable for cases like this.

[rriddle]

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

224–228

Same comment about static vs anonymous namespace.

[math-fehr]

mlir/docs/ExtensibleDialects.md

135–136

I see!
Do you have an intuition on what this interface should look like?
I feel like this interface would be exactly like an attribute, am I missing something?

[rriddle]

mlir/docs/ExtensibleDialects.md

135–136

Do you have an intuition on what this interface should look like?

Not sure given that I have little experience with language binding things, but a more structured version of llvm::Any could work? Type-erased struct that has virtual? methods for accessing information about the value as necessary?

I feel like this interface would be exactly like an attribute, am I missing something?

The differences I see from Attribute are that:

• We wouldn't need to unique each instance (performance win?)

• We wouldn't need to define an Attribute compatible construct for each parameter, which might not be possible

Do we have attributes that cover all of the different things you might put in an attribute? For a python frontend, what values are being placed in attributes? What about for rust? etc.? For very primitive values I can see how we could reuse other existing attribute types, for more complex structs/etc. I'm not sure how that would work.

That being said, maybe using attributes are fine as an initial step.

[math-fehr]

Address comments, and update to HEAD

[math-fehr]

Add some inline responses.
I think that for now it would be better to stick with attributes as parameters to move forward, if that makes sense to you!

mlir/docs/ExtensibleDialects.md

97–107

We don't assert that, but I can add a boolean in the definition that asserts that the operation is registered or not, and then assert in its destructor.
Does that makes sense?

135–136

If we define an attribute for each language, we should be able to represent everything.
However yes, it is probably not optimal in terms of uniquing.
I'll keep it like this for a first step, since I'm not really sure about what would be the exact interface yet.

[rriddle]

Sticking with attributes for now is fine. Will take another pass over in the next day or two, but should be good.

mlir/docs/ExtensibleDialects.md

15

Might want to an an etc. in here given that attributes can also be defined at runtime.

121

created by creating

nit: Can you rephrase?

153–154

Can you align the params here and below?

190–203

The similar boilerplate for parsing types defined in ODS can now be autogenerated, can we work this into that support?

[rriddle]

Thanks! Will likely just need one more round.

mlir/include/mlir/IR/AttributeSupport.h

50

mlir/include/mlir/IR/ExtensibleDialect.h

10–11

Can you beef this up? Or at least reference the more extensive website documentation?

41–42

Why here instead of at the top of the namespace?

43–45

Can you clean this up a bit? It doesn't really describe what a "dynamic type" is.

56

The op?

70

73

nit: Consider switching all of these Get the to Return the to be more consistent with the rest of the codebase.

103

Can you clean this up? It reads a bit weird. The same for the verifier and printer docs.

116–119

124–125

Can you beef this up a bit?

135

This should still call the verifier, but assert if invalid (otherwise it doesn't match what normal types do).

139–140

Please comment on the return if the type is invalid.

171–175

Same comments as the type section.

I would also move the attribute section before the type one, given A<T.

309–311

Can you beef this up?

334–348

Can you document these?

403

Drop the mlir::

467–477

Are all of these llvm:: necessary?

490–499

Why is this necessary? I would expect this to "just work".

mlir/lib/IR/ExtensibleDialect.cpp

229–230

386

Please update all usages of Identifier to StringAttr (they are the same now).

392–395

nit: Can you spell out all of these auto?

[math-fehr]

Address comments

[math-fehr]

Sorry for not being active enough on this, I addressed all comments here.
I tried to add support for TableGen parser/printer generation, and added it in the generated parseType.
Though, I'm not really sure how to integrate it (or if I should integrate it) in generatedTypeParser, since the TableGen generation do not have access to the dialect if there is no TableGen type/attribute definition.

Otherwise, every comment should have been addressed!

mlir/include/mlir/IR/ExtensibleDialect.h

467–477

I removed the ones for DenseMap, though the ones for StringMap are necessary.
I'll make a PR for adding StringMap in the list of LLVM.h aliases, so I don't pollute this PR with this change (and the removing of llvm:: everywhere).

490–499

This is required here because Dialect.h is already overloading it for Dialect with this function:

template <typename T> struct isa_impl<T, ::mlir::Dialect> {
  static inline bool doit(const ::mlir::Dialect &dialect) {
    return mlir::TypeID::get<T>() == dialect.getTypeID();
  }
};

So the cast would call this instead of the usual ExtensibleDialect::classof.

[rriddle]

In D104554#3319622, @math-fehr wrote:

Sorry for not being active enough on this, I addressed all comments here.
I tried to add support for TableGen parser/printer generation, and added it in the generated parseType.
Though, I'm not really sure how to integrate it (or if I should integrate it) in generatedTypeParser, since the TableGen generation do not have access to the dialect if there is no TableGen type/attribute definition.

I think it would be nice to work in if we can. Is the problem that we need to pass in the dialect to the generatedTypeParser method? We could always extend that method to pass in the dialect or something. Either way though, given that we support it in the default generation (which is something we are working towards having on by default), it isn't a huge deal.

I think we've hit a good enough starting point that we can land and start iterating in-tree. Thanks for all of the work on this!

[math-fehr]

Thanks a lot for your reviews!
I'll try to see if I manage to add printing/parsing support in the generatedTypeParser, and I'll try to make a patch for that soon!

Would it be possible to land it for me? I do not have commit access.

[mehdi_amini]

Can you rebase and re-upload?

[math-fehr]

Rebase to main

[math-fehr]

Update to latest commit

[math-fehr]

Apply clang-format

[math-fehr]

I rebased it to the latest commit, though I'm still investigating why the windows build is failing.

[math-fehr]

Fix bug in inheritance, and remove unnecessary code

[awarzynski]

Hi, I've just reverted this as it's been causing build failures in Flang's Windows buildbot: flang-x86_64-windows. I don't have a Windows machine to reproduce myself, but similar build failure was reported by the pre-commit CI:

FAILED: tools/mlir/lib/IR/CMakeFiles/obj.MLIRIR.dir/ExtensibleDialect.cpp.obj
sccache C:\BuildTools\VC\Tools\MSVC\14.29.30133\bin\Hostx64\x64\cl.exe  /nologo /TP -DBUILD_EXAMPLES -DGTEST_HAS_RTTI=0 -DMLIR_CUDA_CONVERSIONS_ENABLED=1 -DMLIR_ROCM_CONVERSIONS_ENABLED=1 -DUNICODE -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_HAS_EXCEPTIONS=0 -D_SCL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS -D_UNICODE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools\mlir\lib\IR -IC:\ws\w4\llvm-project\premerge-checks\mlir\lib\IR -Iinclude -IC:\ws\w4\llvm-project\premerge-checks\llvm\include -IC:\ws\w4\llvm-project\premerge-checks\mlir\include -Itools\mlir\include /DWIN32 /D_WINDOWS   /Zc:inline /Zc:__cplusplus /Zc:strictStrings /Oi /Zc:rvalueCast /bigobj /W4 -wd4141 -wd4146 -wd4244 -wd4267 -wd4291 -wd4351 -wd4456 -wd4457 -wd4458 -wd4459 -wd4503 -wd4624 -wd4722 -wd4100 -wd4127 -wd4512 -wd4505 -wd4610 -wd4510 -wd4702 -wd4245 -wd4706 -wd4310 -wd4701 -wd4703 -wd4389 -wd4611 -wd4805 -wd4204 -wd4577 -wd4091 -wd4592 -wd4319 -wd4709 -wd4324 -w14062 -we4238 /Gw /MD /O2 /Ob2  /EHs-c- /GR- -UNDEBUG -std:c++14 /showIncludes /Fotools\mlir\lib\IR\CMakeFiles\obj.MLIRIR.dir\ExtensibleDialect.cpp.obj /Fdtools\mlir\lib\IR\CMakeFiles\obj.MLIRIR.dir\ /FS -c C:\ws\w4\llvm-project\premerge-checks\mlir\lib\IR\ExtensibleDialect.cpp
C:\ws\w4\llvm-project\premerge-checks\mlir\lib\IR\ExtensibleDialect.cpp(159): error C2672: 'mlir::Type::hasTrait': no matching overloaded function found
C:\ws\w4\llvm-project\premerge-checks\mlir\lib\IR\ExtensibleDialect.cpp(159): error C3207: 'mlir::Type::hasTrait': invalid template argument for 'Trait', class template expected
C:\ws\w4\llvm-project\premerge-checks\mlir\include\mlir/IR/Types.h(174): note: see declaration of 'mlir::Type::hasTrait'
C:\ws\w4\llvm-project\premerge-checks\mlir\lib\IR\ExtensibleDialect.cpp(278): error C2672: 'mlir::Attribute::hasTrait': no matching overloaded function found
C:\ws\w4\llvm-project\premerge-checks\mlir\lib\IR\ExtensibleDialect.cpp(278): error C3207: 'mlir::Attribute::hasTrait': invalid template argument for 'Trait', class template expected
C:\ws\w4\llvm-project\premerge-checks\mlir\include\mlir/IR/Attributes.h(91): note: see declaration of 'mlir::Attribute::hasTrait'

Thanks for working on this and please let me know if I can help in any way!

[math-fehr]

Thanks for taking care of this!
I'll try to figure out why windows is failing, and fix this in the next couple of days!

[math-fehr]

Update to latest version

[rriddle]

The two suggested changes (and the accompanying knock-on changes of those) fixed the build on windows. Don't ask me why, it just does. It also better aligns with how we layer Traits anyways, so seems like a better state overall.

mlir/include/mlir/IR/ExtensibleDialect.h

132–134

276–278

[math-fehr]

Fix compilation on windows machines

[rriddle]

Windows build looks good now, can your reformat/rebase/upload? I can land for you afterwards.

[rriddle]

Also I've recently added real docs for defining dialects (https://mlir.llvm.org/docs/DefiningDialects/), in a follow up patch can we merge the ExtensibleDialects.md doc into that one?

[math-fehr]

Update to latest MLIR, and format files

[math-fehr]

Everything should be ready now! Could you land this for me?
I'll merge the dialect documentation in a following patch!

[math-fehr]

Rename dynamic attributes/types/ops in test dialect

[math-fehr]

I just changed the names of the types, attributes, and ops in the test dialect, to address the comment of D124353.
The patch is otherwise ready if the CI passes.

mlir/docs/ExtensibleDialects.md

+# Extensible dialects
+
+This file documents the design and API of the extensible dialects. Extensible
+dialects are dialects that can be extended with new operations and types defined
+at runtime. This allows for users to define dialects via with meta-programming,
+or from another language, without having to recompile C++ code.
+
+[TOC]
+
+## Usage
+
+### Defining an extensible dialect
+
+Dialects defined in C++ can be extended with new operations and types at runtime
+by inheriting from `mlir::ExtensibleDialect` instead of `mlir::Dialect`
+(note that `ExtensibleDialect` inherits from `Dialect`). The `ExtensibleDialect`
+class contains the necessary fields and methods to extend the dialect at
+runtime.
+
+```c++
+class MyDialect : public mlir::ExtensibleDialect {
+    ...
+}
+```
+
+For dialects defined in TableGen, this is done by setting the `isExtensible`
+flag to `1`.
+
+```tablegen
+def Test_Dialect : Dialect {
+  let isExtensible = 1;
+  ...
+}
+```
+
+An extensible `Dialect` can be casted back to `ExtensibleDialect` using
+`llvm::dyn_cast`, or `llvm::cast`:
+
+```c++
+if (auto extensibleDialect = llvm::dyn_cast<ExtensibleDialect>(dialect)) {
+    ...
+}
+```
+
+### Defining an operation at runtime
+
+The `DynamicOpDefinition` class represents the definition of an operation
+defined at runtime. It is created using the `DynamicOpDefinition::get`
+functions. An operation defined at runtime must provide a name, a dialect in
+which the operation will be registered in, an operation verifier. It may also
+optionally define a custom parser and a printer, fold hook, and more.
+
+```c++
+// The operation name, without the dialect name prefix.
+StringRef name = "my_operation_name";
+
+// The dialect defining the operation.
+Dialect* dialect = ctx->getOrLoadDialect<MyDialect>();
+
+// Operation verifier definition.
+AbstractOperation::VerifyInvariantsFn verifyFn = [](Operation* op) {
+    // Logic for the operation verification.
+    ...
+}
+
+// Parser function definition.
+AbstractOperation::ParseAssemblyFn parseFn =
+    [](OpAsmParser &parser, OperationState &state) {
+        // Parse the operation, given that the name is already parsed.
+        ...    
+};
+
+// Printer function
+auto printFn = [](Operation *op, OpAsmPrinter &printer) {
+        printer << op->getName();
+        // Print the operation, given that the name is already printed.
+        ...
+};
+
+// General folder implementation, see AbstractOperation::foldHook for more
+// information.
+auto foldHookFn = [](Operation * op, ArrayRef<Attribute> operands, 
+                                   SmallVectorImpl<OpFoldResult> &result) {
+    ...
+};
+
+// Returns any canonicalization pattern rewrites that the operation
+// supports, for use by the canonicalization pass.
+auto getCanonicalizationPatterns = 
+        [](RewritePatternSet &results, MLIRContext *context) {
+    ...
+}
+
+// Definition of the operation.
+std::unique_ptr<DynamicOpDefinition> opDef =
+    DynamicOpDefinition::get(name, dialect, std::move(verifyFn),
+        std::move(parseFn), std::move(printFn), std::move(foldHookFn),
+        std::move(getCanonicalizationPatterns));
+```
+
+Once the operation is defined, it can be registered by an `ExtensibleDialect`:
+
+```c++
+extensibleDialect->addDynamicOperation(std::move(opDef));
+```
+
+Note that the `Dialect` given to the operation should be the one registering
+the operation.
+
+### Using an operation defined at runtime
+
+It is possible to match on an operation defined at runtime using their names:
+
+```c++
+if (op->getName().getStringRef() == "my_dialect.my_dynamic_op") {
+    ...
+}
+```
+
+An operation defined at runtime can be created by creating an `OperationState`
+with its name, and passing it to a rewriter such as  a `PatternRewriter`.
+
+```c++
+OperationState state(location, "my_dialect.my_dynamic_op",
+                     operands, resultTypes, attributes);
+
+rewriter.createOperation(state);
+```
+
+
+### Defining a type at runtime
+
+Contrary to types defined in C++ or in TableGen, types defined at runtime can
+only have as argument a list of `Attribute`.
+
+Similarily to operations, a type is defined at runtime using the class
+`DynamicTypeDefinition`, which is created using the `DynamicTypeDefinition::get`
+functions. A type definition requires a name, the dialect that will register the
+type, and a parameter verifier. It can also define optionally a custom parser
+and printer for the arguments (the type name is assumed to be already
+parsed/printed).
+
+```c++
+// The type name, without the dialect name prefix.
+StringRef name = "my_type_name";
+
+// The dialect defining the type.
+Dialect* dialect = ctx->getOrLoadDialect<MyDialect>();
+
+// The type verifier.
+// A type defined at runtime has a list of attributes as parameters.
+auto verifier = [](function_ref<InFlightDiagnostic()> emitError,
+         ArrayRef<Attribute> args) {
+    ...
+};
+
+// The type parameters parser.
+auto parser = [](DialectAsmParser &parser,
+        llvm::SmallVectorImpl<Attribute> &parsedParams) {
+    ...
+};
+
+// The type parameters printer.
+auto printer =[](DialectAsmPrinter &printer, ArrayRef<Attribute> params) {
+    ...
+};
+
+std::unique_ptr<DynamicTypeDefinition> typeDef =
+    DynamicTypeDefinition::get(std::move(name), std::move(dialect),
+            std::move(verifier), std::move(printer), std::move(parser)); 
+```
+
+If the printer and the parser are ommited, a default parser and printer is
+generated with the format `!dialect.typename<arg1, arg2, ..., argN>`.
+
+The type can then be registered by the `ExtensibleDialect`:
+
+```c++
+dialect->addDynamicType(std::move(typeDef));
+```
+
+### Parsing types defined at runtime in an extensible dialect
+
+In order to parse types defined at runtime, it is necessary to add in the
+`MyDialect::parseType` method the necessary support.
+
+```c++
+Type MyDialect::parseType(DialectAsmParser &parser) const {
+    ...
+    // The type name.
+    StringRef typeTag;
+    if (failed(parser.parseKeyword(&typeTag)))
+        return Type();
+
+    // Try to parse a dynamic type with 'typeTag' name.
+    Type dynType;
+    auto parseResult = parseOptionalDynamicType(typeTag, parser, dynType);
+    if (parseResult.hasValue()) {
+        if (succeeded(parseResult.getValue()))
+            return dynType;
+         return Type();
+    }
+```
+
+### Using a type defined at runtime
+
+Dynamic types are instances of `DynamicType`. It is possible to get a dynamic
+type with `DynamicType::get` and `ExtensibleDialect::lookupTypeDefinition`.
+
+```c++
+auto typeDef = extensibleDialect->lookupTypeDefinition("my_dynamic_type");
+ArrayRef<Attribute> params = ...;
+auto type = DynamicType::get(typeDef, params);
+```
+
+It is also possible to cast a `Type` known to be defined at runtime to a
+`DynamicType`.
+
+```c++
+auto dynType = type.cast<DynamicType>();
+auto typeDef = dynType.getTypeDef();
+auto args = dynType.getParams();
+```
+
+### Defining an attribute at runtime
+
+Similar to types defined at runtime, attributes defined at runtime can only have
+as argument a list of `Attribute`.
+
+Similarily to types, an attribute is defined at runtime using the class
+`DynamicAttrDefinition`, which is created using the `DynamicAttrDefinition::get`
+functions. An attribute definition requires a name, the dialect that will
+register the attribute, and a parameter verifier. It can also define optionally
+a custom parser and printer for the arguments (the attribute name is assumed to
+be already parsed/printed).
+
+```c++
+// The attribute name, without the dialect name prefix.
+StringRef name = "my_attribute_name";
+
+// The dialect defining the attribute.
+Dialect* dialect = ctx->getOrLoadDialect<MyDialect>();
+
+// The attribute verifier.
+// An attribute defined at runtime has a list of attributes as parameters.
+auto verifier = [](function_ref<InFlightDiagnostic()> emitError,
+         ArrayRef<Attribute> args) {
+    ...
+};
+
+// The attribute parameters parser.
+auto parser = [](DialectAsmParser &parser,
+        llvm::SmallVectorImpl<Attribute> &parsedParams) {
+    ...
+};
+
+// The attribute parameters printer.
+auto printer =[](DialectAsmPrinter &printer, ArrayRef<Attribute> params) {
+    ...
+};
+
+std::unique_ptr<DynamicAttrDefinition> attrDef =
+    DynamicAttrDefinition::get(std::move(name), std::move(dialect),
+            std::move(verifier), std::move(printer), std::move(parser)); 
+```
+
+If the printer and the parser are ommited, a default parser and printer is
+generated with the format `!dialect.attrname<arg1, arg2, ..., argN>`.
+
+The attribute can then be registered by the `ExtensibleDialect`:
+
+```c++
+dialect->addDynamicAttr(std::move(typeDef));
+```
+
+### Parsing attributes defined at runtime in an extensible dialect
+
+In order to parse attributes defined at runtime, it is necessary to add in the
+`MyDialect::parseAttribute` method the necessary support.
+
+```c++
+Attribute MyDialect::parseAttribute(DialectAsmParser &parser,
+                                    Type type) const override {
+    ...
+    // The attribute name.
+    StringRef attrTag;
+    if (failed(parser.parseKeyword(&attrTag)))
+        return Attribute();
+
+    // Try to parse a dynamic attribute with 'attrTag' name.
+    Attribute dynAttr;
+    auto parseResult = parseOptionalDynamicAttr(attrTag, parser, dynAttr);
+    if (parseResult.hasValue()) {
+        if (succeeded(parseResult.getValue()))
+            return dynAttr;
+         return Attribute();
+    }
+```
+
+### Using an attribute defined at runtime
+
+Similar to types, attributes defined at runtime are instances of `DynamicAttr`.
+It is possible to get a dynamic attribute with `DynamicAttr::get` and
+`ExtensibleDialect::lookupAttrDefinition`.
+
+```c++
+auto attrDef = extensibleDialect->lookupAttrDefinition("my_dynamic_attr");
+ArrayRef<Attribute> params = ...;
+auto attr = DynamicAttr::get(attrDef, params);
+```
+
+It is also possible to cast an `Attribute` known to be defined at runtime to a
+`DynamicAttr`.
+
+```c++
+auto dynAttr = attr.cast<DynamicAttr>();
+auto attrDef = dynAttr.getAttrDef();
+auto args = dynAttr.getParams();
+```
+
+## Implementation details
+
+### Extensible dialect
+
+The role of extensible dialects is to own the necessary data for defined
+operations and types. They also contain the necessary accessors to easily
+access them.
+
+In order to cast a `Dialect` back to an `ExtensibleDialect`, we implement the
+`IsExtensibleDialect` interface to all `ExtensibleDialect`. The casting is done
+by checking if the `Dialect` implements `IsExtensibleDialect` or not.
+
+### Operation representation and registration
+
+Operations are represented in mlir using the `AbstractOperation` class. They are
+registered in dialects the same way operations defined in C++ are registered,
+which is by calling `AbstractOperation::insert`.
+
+The only difference is that a new `TypeID` needs to be created for each
+operation, since operations are not represented by a C++ class. This is done
+using a `TypeIDAllocator`, which can allocate a new unique `TypeID` at runtime.
+
+### Type representation and registration
+
+Unlike operations, types need to define a C++ storage class that takes care of
+type parameters. They also need to define another C++ class to access that
+storage. `DynamicTypeStorage` defines the storage of types defined at runtime,
+and `DynamicType` gives access to the storage, as well as defining useful
+functions. A `DynamicTypeStorage` contains a list of `Attribute` type
+parameters, as well as a pointer to the type definition.
+
+Types are registered using the `Dialect::addType` method, which expect a
+`TypeID` that is generated using a `TypeIDAllocator`. The type uniquer also
+register the type with the given `TypeID`. This mean that we can reuse our
+single `DynamicType` with different `TypeID` to represent the different types
+defined at runtime.
+
+Since the different types defined at runtime have different `TypeID`, it is not
+possible to use `TypeID` to cast a `Type` into a `DynamicType`. Thus, similar to
+`Dialect`, all `DynamicType` define a `IsDynamicTypeTrait`, so casting a `Type`
+to a `DynamicType` boils down to querying the `IsDynamicTypeTrait` trait.

mlir/include/mlir/IR/AttributeSupport.h

public:
   /// This method is used by Dialect objects when they register the list of
   /// attributes they contain.
   template <typename T>
   static AbstractAttribute get(Dialect &dialect) {
     return AbstractAttribute(dialect, T::getInterfaceMap(), T::getHasTraitFn(),
                              T::getTypeID());
   }
 
+  /// This method is used by Dialect objects to register attributes with
+  /// custom TypeIDs.
+  /// The use of this method is in general discouraged in favor of
+  /// 'get<CustomAttribute>(dialect)';
+  static AbstractAttribute get(Dialect &dialect,
+                               detail::InterfaceMap &&interfaceMap,
+                               HasTraitFn &&hasTrait, TypeID typeID) {
+    return AbstractAttribute(dialect, std::move(interfaceMap),
+                             std::move(hasTrait), typeID);
+  }
+
   /// Return the dialect this attribute was registered to.
   Dialect &getDialect() const { return const_cast<Dialect &>(dialect); }
 
   /// Returns an instance of the concept object for the given interface if it
   /// was registered to this attribute, null otherwise. This should not be used
   /// directly.
   template <typename T>
   typename T::Concept *getInterface() const {

 //===----------------------------------------------------------------------===//
 // AttributeUniquer
 //===----------------------------------------------------------------------===//
 namespace detail {
 // A utility class to get, or create, unique instances of attributes within an
 // MLIRContext. This class manages all creation and uniquing of attributes.
 class AttributeUniquer {
 public:
+  /// Get an uniqued instance of an attribute T.
+  template <typename T, typename... Args>
+  static T get(MLIRContext *ctx, Args &&...args) {
+    return getWithTypeID<T, Args...>(ctx, T::getTypeID(),
+                                     std::forward<Args>(args)...);
+  }
+
   /// Get an uniqued instance of a parametric attribute T.
+  /// The use of this method is in general discouraged in favor of
+  /// 'get<T, Args>(ctx, args)'.
   template <typename T, typename... Args>
   static typename std::enable_if_t<
       !std::is_same<typename T::ImplType, AttributeStorage>::value, T>
-  get(MLIRContext *ctx, Args &&...args) {
+  getWithTypeID(MLIRContext *ctx, TypeID typeID, Args &&...args) {
 #ifndef NDEBUG
     if (!ctx->getAttributeUniquer().isParametricStorageInitialized(
-            T::getTypeID()))
+            typeID))
       llvm::report_fatal_error(llvm::Twine("can't create Attribute '") +
                                llvm::getTypeName<T>() +
                                "' because storage uniquer isn't initialized: "
                                "the dialect was likely not loaded.");
 #endif
     return ctx->getAttributeUniquer().get<typename T::ImplType>(
-        [ctx](AttributeStorage *storage) {
-          initializeAttributeStorage(storage, ctx, T::getTypeID());
+        [ctx, typeID](AttributeStorage *storage) {
+          initializeAttributeStorage(storage, ctx, typeID);
         },
-        T::getTypeID(), std::forward<Args>(args)...);
+        typeID, std::forward<Args>(args)...);
   }
   /// Get an uniqued instance of a singleton attribute T.
+  /// The use of this method is in general discouraged in favor of
+  /// 'get<T, Args>(ctx, args)'.
   template <typename T>
   static typename std::enable_if_t<
       std::is_same<typename T::ImplType, AttributeStorage>::value, T>
-  get(MLIRContext *ctx) {
+  getWithTypeID(MLIRContext *ctx, TypeID typeID) {
 #ifndef NDEBUG
     if (!ctx->getAttributeUniquer().isSingletonStorageInitialized(
-            T::getTypeID()))
+            typeID))
       llvm::report_fatal_error(llvm::Twine("can't create Attribute '") +
                                llvm::getTypeName<T>() +
                                "' because storage uniquer isn't initialized: "
                                "the dialect was likely not loaded.");
 #endif
-    return ctx->getAttributeUniquer().get<typename T::ImplType>(T::getTypeID());
+    return ctx->getAttributeUniquer().get<typename T::ImplType>(typeID);
   }
 
   template <typename T, typename... Args>
   static LogicalResult mutate(MLIRContext *ctx, typename T::ImplType *impl,
                               Args &&...args) {
     assert(impl && "cannot mutate null attribute");
     return ctx->getAttributeUniquer().mutate(T::getTypeID(), impl,
                                              std::forward<Args>(args)...);
   }
 
+  /// Register an attribute instance T with the uniquer.
+  template <typename T>
+  static void registerAttribute(MLIRContext *ctx) {
+    registerAttribute<T>(ctx, T::getTypeID());
+  }
+
   /// Register a parametric attribute instance T with the uniquer.
+  /// The use of this method is in general discouraged in favor of
+  /// 'registerAttribute<T>(ctx)'.
   template <typename T>
   static typename std::enable_if_t<
       !std::is_same<typename T::ImplType, AttributeStorage>::value>
-  registerAttribute(MLIRContext *ctx) {
+  registerAttribute(MLIRContext *ctx, TypeID typeID) {
     ctx->getAttributeUniquer()
-        .registerParametricStorageType<typename T::ImplType>(T::getTypeID());
+      .registerParametricStorageType<typename T::ImplType>(typeID);
   }
   /// Register a singleton attribute instance T with the uniquer.
+  /// The use of this method is in general discouraged in favor of
+  /// 'registerAttribute<T>(ctx)'.
   template <typename T>
   static typename std::enable_if_t<
       std::is_same<typename T::ImplType, AttributeStorage>::value>
-  registerAttribute(MLIRContext *ctx) {
+  registerAttribute(MLIRContext *ctx, TypeID typeID) {
     ctx->getAttributeUniquer()
         .registerSingletonStorageType<typename T::ImplType>(
-            T::getTypeID(), [ctx](AttributeStorage *storage) {
-              initializeAttributeStorage(storage, ctx, T::getTypeID());
+            typeID, [ctx, typeID](AttributeStorage *storage) {
+              initializeAttributeStorage(storage, ctx, typeID);
             });
   }
 
 private:
   /// Initialize the given attribute storage instance.
   static void initializeAttributeStorage(AttributeStorage *storage,
                                          MLIRContext *ctx, TypeID attrID);
 };
 } // namespace detail
 
 } // end namespace mlir
 
 #endif

mlir/include/mlir/IR/Dialect.h

protected:
   /// 'addTypes<CustomType>()'.
   void addType(TypeID typeID, AbstractType &&typeInfo);
 
   /// Register a set of attribute classes with this dialect.
   template <typename... Args> void addAttributes() {
     (void)std::initializer_list<int>{0, (addAttribute<Args>(), 0)...};
   }
 
+  /// Register an attribute instance with this dialect.
+  /// The use of this method is in general discouraged in favor of
+  /// 'addAttributes<CustomAttr>()'.
+  void addAttribute(TypeID typeID, AbstractAttribute &&attrInfo);
+
   /// Enable support for unregistered operations.
   void allowUnknownOperations(bool allow = true) { unknownOpsAllowed = allow; }
 
   /// Enable support for unregistered types.
   void allowUnknownTypes(bool allow = true) { unknownTypesAllowed = allow; }
 
   /// Register a dialect interface with this dialect instance.
   void addInterface(std::unique_ptr<DialectInterface> interface);
private:
   void operator=(Dialect &) = delete;
 
   /// Register an attribute instance with this dialect.
   template <typename T> void addAttribute() {
     // Add this attribute to the dialect and register it with the uniquer.
     addAttribute(T::getTypeID(), AbstractAttribute::get<T>(*this));
     detail::AttributeUniquer::registerAttribute<T>(context);
   }
-  void addAttribute(TypeID typeID, AbstractAttribute &&attrInfo);
 
   /// Register a type instance with this dialect.
   template <typename T> void addType() {
     // Add this type to the dialect and register it with the uniquer.
     addType(T::getTypeID(), AbstractType::get<T>(*this));
     detail::TypeUniquer::registerType<T>(context);
   }
 

mlir/include/mlir/IR/ExtensibleDialect.h

+//===- ExtensibleDialect.h - Extensible dialect -----------------*- C++ -*-===//
+//
+// This file is licensed 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Dialects that can register new operations/types/attributes at runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_IR_EXTENSIBLEDIALECT_H
+#define MLIR_IR_EXTENSIBLEDIALECT_H
+
+#include "mlir/IR/Dialect.h"
+#include "mlir/IR/DialectInterface.h"
+#include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/OpDefinition.h"
+#include "llvm/ADT/StringMap.h"
+
+namespace mlir {
+class MLIRContext;
+class DialectAsmPrinter;
+class DialectAsmParser;
+class ParseResult;
+class OptionalParseResult;
+class ExtensibleDialect;
+
+namespace detail {
+struct DynamicTypeStorage;
+struct DynamicAttrStorage;
+} // namespace detail
+
+//===----------------------------------------------------------------------===//
+// Dynamic type
+//===----------------------------------------------------------------------===//
+
+class DynamicType;
+
+/// This is the definition of a dynamic type. It stores the parser,
+/// the printer, and the verifier.
+/// Each dynamic type definition refer to one instance of this class.
+class DynamicTypeDefinition {
+public:
+  using VerifierFn = llvm::unique_function<LogicalResult(
+      function_ref<InFlightDiagnostic()>, ArrayRef<Attribute>) const>;
+  using ParserFn = llvm::unique_function<ParseResult(
+      DialectAsmParser &parser,
+      llvm::SmallVectorImpl<Attribute> &parsedAttributes) const>;
+  using PrinterFn = llvm::unique_function<void(
+      DialectAsmPrinter &printer, ArrayRef<Attribute> params) const>;
+
+  static std::unique_ptr<DynamicTypeDefinition>
+  get(llvm::StringRef name, Dialect *dialect, VerifierFn &&verifier);
+
+  static std::unique_ptr<DynamicTypeDefinition>
+  get(llvm::StringRef name, Dialect *dialect, VerifierFn &&verifier,
+      ParserFn &&parser, PrinterFn &&printer);
+
+  /// Check that the type parameters are valid.
+  LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                       ArrayRef<Attribute> params) const {
+    return verifier(emitError, params);
+  }
+
+  /// Get the unique identifier associated with the concrete type.
+  TypeID getTypeID() const { return typeID; }
+
+  /// Get the MLIRContext in which the dynamic types are uniqued.
+  MLIRContext &getContext() const { return *ctx; }
+
+  /// Get the name of the type, in the format 'typename' and
+  /// not 'dialectname.typename'.
+  StringRef getName() const { return name; }
+
+  /// Get the dialect defining the type.
+  Dialect *getDialect() const { return dialect; }
+
+private:
+  DynamicTypeDefinition(llvm::StringRef name, Dialect *dialect,
+                        VerifierFn &&verifier, ParserFn &&parser,
+                        PrinterFn &&printer);
+
+  /// This constructor should only be used when we need a pointer to
+  /// the DynamicTypeDefinition in the verifier, the parser, or the printer.
+  /// The verifier, parser, and printer need thus to be initialized after the
+  /// constructor.
+  DynamicTypeDefinition(Dialect *dialect, llvm::StringRef name);
+
+  /// Register the concrete type in the type Uniquer.
+  void registerInTypeUniquer();
+
+  /// The name should be prefixed with the dialect name followed by '.'.
+  std::string name;
+
+  /// Dialect in which this type is defined.
+  Dialect *dialect;
+
+  /// Verifier for the type parameters.
+  VerifierFn verifier;
+
+  /// Parse the type parameters.
+  ParserFn parser;
+
+  /// Print the type parameters.
+  PrinterFn printer;
+
+  /// Unique identifier for the concrete type.
+  TypeID typeID;
+
+  /// Context in which the concrete types are uniqued.
+  MLIRContext *ctx;
+
+  friend ExtensibleDialect;
+  friend DynamicType;
+};
+
+/// This trait is implemented by all dynamic types, and should not be
+/// implemented by any other type.
+/// The trait is only used to check if a type is a dynamic type or not.
+/// This is required because dynamic type do not have a single TypeID.
+template <typename ConcreteType>
+class IsDynamicTypeTrait
+    : TypeTrait::TraitBase<ConcreteType, IsDynamicTypeTrait> {};
+
+/// A type defined at runtime.
+/// Each DynamicType instance represent a different dynamic type.
+class DynamicType
+    : public Type::TypeBase<DynamicType, Type, detail::DynamicTypeStorage,
+                            IsDynamicTypeTrait> {
+public:
+  // Inherit Base constructors.
+  using Base::Base;
+
+  /// Get an instance of a dynamic type given a dynamic type definition and
+  /// type parameters.
+  /// This function does not call the type verifier.
+  static DynamicType get(DynamicTypeDefinition *typeDef,
+                         ArrayRef<Attribute> params = {});
+
+  /// Get an instance of a dynamic type given a dynamic type definition and type
+  /// parameters.
+  /// This function also call the verifier to check if the parameters are valid.
+  static DynamicType getChecked(function_ref<InFlightDiagnostic()> emitError,
+                                DynamicTypeDefinition *typeDef,
+                                ArrayRef<Attribute> params = {});
+
+  /// Get the type definition of the concrete type.
+  DynamicTypeDefinition *getTypeDef();
+
+  /// Get the type parameters.
+  ArrayRef<Attribute> getParams();
+
+  /// Check if a type is a specific dynamic type.
+  static bool isa(Type type, DynamicTypeDefinition *typeDef) {
+    return type.getTypeID() == typeDef->getTypeID();
+  }
+
+  /// Check if a type is a dynamic type.
+  static bool classof(Type type);
+
+  /// Parse the dynamic type parameters and construct the type.
+  /// The parameters are either empty, and nothing is parsed,
+  /// or they are in the format '<>' or '<attr (,attr)*>'.
+  static ParseResult parse(DialectAsmParser &parser,
+                           DynamicTypeDefinition *typeDef,
+                           DynamicType &parsedType);
+
+  /// Print the dynamic type with the format
+  /// 'type' or 'type<>' if there is no parameters, or 'type<attr (,attr)*>'.
+  void print(DialectAsmPrinter &printer);
+};
+
+//===----------------------------------------------------------------------===//
+// Dynamic attribute
+//===----------------------------------------------------------------------===//
+
+class DynamicAttr;
+
+/// This is the definition of a dynamic attribute. It stores the parser,
+/// the printer, and the verifier.
+/// Each dynamic attribute definition refer to one instance of this class.
+class DynamicAttrDefinition {
+public:
+  using VerifierFn = llvm::unique_function<LogicalResult(
+      function_ref<InFlightDiagnostic()>, ArrayRef<Attribute>) const>;
+  using ParserFn = llvm::unique_function<ParseResult(
+      DialectAsmParser &parser,
+      llvm::SmallVectorImpl<Attribute> &parsedAttributes) const>;
+  using PrinterFn = llvm::unique_function<void(
+      DialectAsmPrinter &printer, ArrayRef<Attribute> params) const>;
+
+  static std::unique_ptr<DynamicAttrDefinition>
+  get(llvm::StringRef name, Dialect *dialect, VerifierFn &&verifier);
+
+  static std::unique_ptr<DynamicAttrDefinition>
+  get(llvm::StringRef name, Dialect *dialect, VerifierFn &&verifier,
+      ParserFn &&parser, PrinterFn &&printer);
+
+  /// Check that the attribute parameters are valid.
+  LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                       ArrayRef<Attribute> params) const {
+    return verifier(emitError, params);
+  }
+
+  /// Get the unique identifier associated with the concrete attribute.
+  TypeID getTypeID() const { return typeID; }
+
+  /// Get the MLIRContext in which the dynamic attributes are uniqued.
+  MLIRContext &getContext() const { return *ctx; }
+
+  /// Get the name of the attribute, in the format 'attrname' and
+  /// not 'dialectname.attrname'.
+  StringRef getName() const { return name; }
+
+  /// Get the dialect defining the attribute.
+  Dialect *getDialect() const { return dialect; }
+
+private:
+  DynamicAttrDefinition(llvm::StringRef name, Dialect *dialect,
+                        VerifierFn &&verifier, ParserFn &&parser,
+                        PrinterFn &&printer);
+
+  /// This constructor should only be used when we need a pointer to
+  /// the DynamicAttrDefinition in the verifier, the parser, or the printer.
+  /// The verifier, parser, and printer need thus to be initialized after the
+  /// constructor.
+  DynamicAttrDefinition(Dialect *dialect, llvm::StringRef name);
+
+  /// Register the concrete attribute in the attribute Uniquer.
+  void registerInAttrUniquer();
+
+  /// The name should be prefixed with the dialect name followed by '.'.
+  std::string name;
+
+  /// Dialect in which this attribute is defined.
+  Dialect *dialect;
+
+  /// Verifier for the attribute parameters.
+  VerifierFn verifier;
+
+  /// Parse the attribute parameters.
+  ParserFn parser;
+
+  /// Print the attribute parameters.
+  PrinterFn printer;
+
+  /// Unique identifier for the concrete attribute.
+  TypeID typeID;
+
+  /// Context in which the concrete attributes are uniqued.
+  MLIRContext *ctx;
+
+  friend ExtensibleDialect;
+  friend DynamicAttr;
+};
+
+/// This trait is implemented by all dynamic attributes, and should not be
+/// implemented by any other attribute.
+/// The trait is only used to check if an attribute is a dynamic attribute or
+/// not. This is required because dynamic attribute do not have a single TypeID.
+template <typename ConcreteType>
+class IsDynamicAttrTrait
+    : AttributeTrait::TraitBase<ConcreteType, IsDynamicAttrTrait> {};
+
+/// An attribute defined at runtime.
+/// Each DynamicAttr instance represent a different dynamic attribute.
+class DynamicAttr : public Attribute::AttrBase<DynamicAttr, Attribute,
+                                               detail::DynamicAttrStorage,
+                                               IsDynamicAttrTrait> {
+public:
+  // Inherit Base constructors.
+  using Base::Base;
+
+  /// Get an instance of a dynamic attribute given a dynamic attribute
+  /// definition and attribute parameters.
+  /// This function does not call the attribute verifier.
+  static DynamicAttr get(DynamicAttrDefinition *attrDef,
+                         ArrayRef<Attribute> params = {});
+
+  /// Get an instance of a dynamic attribute given a dynamic attribute
+  /// definition and attribute parameters.
+  /// This function also call the verifier to check if the parameters are valid.
+  static DynamicAttr getChecked(function_ref<InFlightDiagnostic()> emitError,
+                                DynamicAttrDefinition *attrDef,
+                                ArrayRef<Attribute> params = {});
+
+  /// Get the attribute definition of the concrete attribute.
+  DynamicAttrDefinition *getAttrDef();
+
+  /// Get the attribute parameters.
+  ArrayRef<Attribute> getParams();
+
+  /// Check if an attribute is a specific dynamic attribute.
+  static bool isa(Attribute attr, DynamicAttrDefinition *attrDef) {
+    return attr.getTypeID() == attrDef->getTypeID();
+  }
+
+  /// Check if an attribute is a dynamic attribute.
+  static bool classof(Attribute attr);
+
+  /// Parse the dynamic attribute parameters and construct the attribute.
+  /// The parameters are either empty, and nothing is parsed,
+  /// or they are in the format '<>' or '<attr (,attr)*>'.
+  static ParseResult parse(DialectAsmParser &parser,
+                           DynamicAttrDefinition *attrDef,
+                           DynamicAttr &parsedAttr);
+
+  /// Print the dynamic attribute with the format 'attrname' if there is no
+  /// parameters, or 'attrname<attr (,attr)*>'.
+  void print(DialectAsmPrinter &printer);
+};
+
+//===----------------------------------------------------------------------===//
+// Dynamic operation
+//===----------------------------------------------------------------------===//
+
+/// The definition of a dynamic operation.
+/// It contains the name of the operation, its owning dialect, a verifier,
+/// a printer, and parser.
+class DynamicOpDefinition {
+public:
+  static std::unique_ptr<DynamicOpDefinition>
+  get(StringRef name, Dialect *dialect,
+      AbstractOperation::VerifyInvariantsFn &&verifyFn);
+
+  static std::unique_ptr<DynamicOpDefinition>
+  get(StringRef name, Dialect *dialect,
+      AbstractOperation::VerifyInvariantsFn &&verifyFn,
+      AbstractOperation::ParseAssemblyFn &&parseFn,
+      AbstractOperation::PrintAssemblyFn &&printFn);
+
+  static std::unique_ptr<DynamicOpDefinition>
+  get(StringRef name, Dialect *dialect,
+      AbstractOperation::VerifyInvariantsFn &&verifyFn,
+      AbstractOperation::ParseAssemblyFn &&parseFn,
+      AbstractOperation::PrintAssemblyFn &&printFn,
+      AbstractOperation::FoldHookFn &&foldHookFn,
+      AbstractOperation::GetCanonicalizationPatternsFn
+          &&getCanonicalizationPatternsFn);
+
+  void setVerifyFn(AbstractOperation::VerifyInvariantsFn &&verify) {
+    verifyFn = std::move(verify);
+  }
+
+  void setParseFn(AbstractOperation::ParseAssemblyFn &&parse) {
+    parseFn = std::move(parse);
+  }
+
+  void setPrintFn(AbstractOperation::PrintAssemblyFn &&print) {
+    printFn = std::move(print);
+  }
+
+  void setFoldHookFn(AbstractOperation::FoldHookFn &&foldHook) {
+    foldHookFn = std::move(foldHook);
+  }
+
+  void setGetCanonicalizationPatternsFn(
+      AbstractOperation::GetCanonicalizationPatternsFn
+          &&getCanonicalizationPatterns) {
+    getCanonicalizationPatternsFn = std::move(getCanonicalizationPatterns);
+  }
+
+private:
+  DynamicOpDefinition(StringRef name, Dialect *dialect,
+                      AbstractOperation::VerifyInvariantsFn &&verifyFn,
+                      AbstractOperation::ParseAssemblyFn &&parseFn,
+                      AbstractOperation::PrintAssemblyFn &&printFn,
+                      AbstractOperation::FoldHookFn &&foldHookFn,
+                      AbstractOperation::GetCanonicalizationPatternsFn
+                          &&getCanonicalizationPatternsFn);
+
+  /// Unique identifier for this operation.
+  TypeID typeID;
+
+  /// Name of the operation.
+  /// The name is prefixed with the dialect name.
+  std::string name;
+
+  /// Dialect defining this operation.
+  Dialect *dialect;
+
+  AbstractOperation::VerifyInvariantsFn verifyFn;
+  AbstractOperation::ParseAssemblyFn parseFn;
+  AbstractOperation::PrintAssemblyFn printFn;
+  AbstractOperation::FoldHookFn foldHookFn;
+  AbstractOperation::GetCanonicalizationPatternsFn
+      getCanonicalizationPatternsFn;
+
+  friend ExtensibleDialect;
+};
+
+//===----------------------------------------------------------------------===//
+// Extensible dialect
+//===----------------------------------------------------------------------===//
+
+/// A dialect that can be extended with new operations/types/attributes at
+/// runtime.
+class ExtensibleDialect : public mlir::Dialect {
+public:
+  ExtensibleDialect(StringRef name, MLIRContext *ctx, TypeID typeID);
+
+  /// Add a new type defined at runtime to the dialect.
+  void addDynamicType(std::unique_ptr<DynamicTypeDefinition> &&type);
+
+  /// Add a new attribute defined at runtime to the dialect.
+  void addDynamicAttr(std::unique_ptr<DynamicAttrDefinition> &&attr);
+
+  /// Add a new operation defined at runtime to the dialect.
+  void addDynamicOp(std::unique_ptr<DynamicOpDefinition> &&type);
+
+  /// Check if the dialect is an extensible dialect.
+  static bool classof(const mlir::Dialect *dialect);
+
+  /// Returns nullptr if the definition was not found.
+  DynamicTypeDefinition *lookupTypeDefinition(StringRef name) const {
+    auto it = nameToDynTypes.find(name);
+    if (it == nameToDynTypes.end())
+      return nullptr;
+    return it->second;
+  }
+
+  /// Returns nullptr if the definition was not found.
+  DynamicTypeDefinition *lookupTypeDefinition(TypeID id) const {
+    auto it = dynTypes.find(id);
+    if (it == dynTypes.end())
+      return nullptr;
+    return it->second.get();
+  }
+
+  /// Returns nullptr if the definition was not found.
+  DynamicAttrDefinition *lookupAttrDefinition(StringRef name) const {
+    auto it = nameToDynAttrs.find(name);
+    if (it == nameToDynAttrs.end())
+      return nullptr;
+    return it->second;
+  }
+
+  /// Returns nullptr if the definition was not found.
+  DynamicAttrDefinition *lookupAttrDefinition(TypeID id) const {
+    auto it = dynAttrs.find(id);
+    if (it == dynAttrs.end())
+      return nullptr;
+    return it->second.get();
+  }
+
+protected:
+  /// Parse the dynamic type 'typeName' in the dialect 'dialect'.
+  /// typename should not be prefixed with the dialect name.
+  /// If the dynamic type does not exist, return no value.
+  /// Otherwise, parse it, and return the parse result.
+  /// If the parsing succeed, put the resulting type in 'resultType'.
+  OptionalParseResult parseOptionalDynamicType(StringRef typeName,
+                                               DialectAsmParser &parser,
+                                               Type &resultType) const;
+
+  /// If 'type' is a dynamic type, print it.
+  /// Returns success if the type was printed, and failure if the type was not a
+  /// dynamic type.
+  static LogicalResult printIfDynamicType(Type type,
+                                          DialectAsmPrinter &printer);
+
+  /// Parse the dynamic attribute 'attrName' in the dialect 'dialect'.
+  /// attrname should not be prefixed with the dialect name.
+  /// If the dynamic attribute does not exist, return no value.
+  /// Otherwise, parse it, and return the parse result.
+  /// If the parsing succeed, put the resulting attribute in 'resultAttr'.
+  OptionalParseResult parseOptionalDynamicAttr(StringRef attrName,
+                                               DialectAsmParser &parser,
+                                               Attribute &resultAttr) const;
+
+  /// If 'attr' is a dynamic attribute, print it.
+  /// Returns success if the attribute was printed, and failure if the
+  /// attribute was not a dynamic attribute.
+  static LogicalResult printIfDynamicAttr(Attribute attr,
+                                          DialectAsmPrinter &printer);
+
+private:
+  /// The set of all dynamic types registered.
+  llvm::DenseMap<TypeID, std::unique_ptr<DynamicTypeDefinition>> dynTypes;
+
+  /// This structure allows to get in O(1) a dynamic type given its name.
+  llvm::StringMap<DynamicTypeDefinition *> nameToDynTypes;
+
+  /// The set of all dynamic attributes registered.
+  llvm::DenseMap<TypeID, std::unique_ptr<DynamicAttrDefinition>> dynAttrs;
+
+  /// This structure allows to get in O(1) a dynamic attribute given its name.
+  llvm::StringMap<DynamicAttrDefinition *> nameToDynAttrs;
+};
+} // namespace mlir
+
+namespace llvm {
+/// Provide isa functionality for ExtensibleDialect.
+/// This is to override the isa functionality for Dialect.
+template <>
+struct isa_impl<mlir::ExtensibleDialect, mlir::Dialect> {
+  static inline bool doit(const ::mlir::Dialect &dialect) {
+    return mlir::ExtensibleDialect::classof(&dialect);
+  }
+};
+} // namespace llvm
+
+#endif // MLIR_IR_EXTENSIBLEDIALECT_H

mlir/include/mlir/IR/OpBase.td

class Dialect {
   // If this dialect overrides the hook for verifying region result attributes.
   bit hasRegionResultAttrVerify = 0;
 
   // If this dialect overrides the hook for op interface fallback.
   bit hasOperationInterfaceFallback = 0;
 
   // If this dialect overrides the hook for canonicalization patterns.
   bit hasCanonicalizer = 0;
+
+  // If this dialect can be extended at runtime with new operations or types.
+  bit isExtensible = 0;
 }
 
 //===----------------------------------------------------------------------===//
 // Type definitions
 //===----------------------------------------------------------------------===//
 
 // A type, carries type constraints.
 class Type<Pred condition, string descr = "",

mlir/include/mlir/IR/TypeSupport.h

 
 //===----------------------------------------------------------------------===//
 // TypeUniquer
 //===----------------------------------------------------------------------===//
 namespace detail {
 /// A utility class to get, or create, unique instances of types within an
 /// MLIRContext. This class manages all creation and uniquing of types.
 struct TypeUniquer {
+  /// Get an uniqued instance of a type T.
+  template <typename T, typename... Args>
+  static T get(MLIRContext *ctx, Args &&...args) {
+    return getWithTypeID<T, Args...>(ctx, T::getTypeID(),
+                                     std::forward<Args>(args)...);
+  }
+
   /// Get an uniqued instance of a parametric type T.
+  /// The use of this method is in general discouraged in favor of
+  /// 'get<T, Args>(ctx, args)'.
   template <typename T, typename... Args>
   static typename std::enable_if_t<
       !std::is_same<typename T::ImplType, TypeStorage>::value, T>
-  get(MLIRContext *ctx, Args &&...args) {
+  getWithTypeID(MLIRContext *ctx, TypeID typeID, Args &&...args) {
 #ifndef NDEBUG
-    if (!ctx->getTypeUniquer().isParametricStorageInitialized(T::getTypeID()))
+    if (!ctx->getTypeUniquer().isParametricStorageInitialized(typeID))
       llvm::report_fatal_error(llvm::Twine("can't create type '") +
                                llvm::getTypeName<T>() +
                                "' because storage uniquer isn't initialized: "
                                "the dialect was likely not loaded.");
 #endif
     return ctx->getTypeUniquer().get<typename T::ImplType>(
-        [&](TypeStorage *storage) {
-          storage->initialize(AbstractType::lookup(T::getTypeID(), ctx));
+        [&, typeID](TypeStorage *storage) {
+          storage->initialize(AbstractType::lookup(typeID, ctx));
         },
-        T::getTypeID(), std::forward<Args>(args)...);
+        typeID, std::forward<Args>(args)...);
   }
   /// Get an uniqued instance of a singleton type T.
+  /// The use of this method is in general discouraged in favor of
+  /// 'get<T, Args>(ctx, args)'.
   template <typename T>
   static typename std::enable_if_t<
       std::is_same<typename T::ImplType, TypeStorage>::value, T>
-  get(MLIRContext *ctx) {
+  getWithTypeID(MLIRContext *ctx, TypeID typeID) {
 #ifndef NDEBUG
-    if (!ctx->getTypeUniquer().isSingletonStorageInitialized(T::getTypeID()))
+    if (!ctx->getTypeUniquer().isSingletonStorageInitialized(typeID))
       llvm::report_fatal_error(llvm::Twine("can't create type '") +
                                llvm::getTypeName<T>() +
                                "' because storage uniquer isn't initialized: "
                                "the dialect was likely not loaded.");
 #endif
-    return ctx->getTypeUniquer().get<typename T::ImplType>(T::getTypeID());
+    return ctx->getTypeUniquer().get<typename T::ImplType>(typeID);
   }
 
   /// Change the mutable component of the given type instance in the provided
   /// context.
   template <typename T, typename... Args>
   static LogicalResult mutate(MLIRContext *ctx, typename T::ImplType *impl,
                               Args &&...args) {
     assert(impl && "cannot mutate null type");
     return ctx->getTypeUniquer().mutate(T::getTypeID(), impl,
                                         std::forward<Args>(args)...);
   }
 
+  /// Register a type instance T with the uniquer.
+  template <typename T>
+  static void registerType(MLIRContext *ctx) {
+    registerType<T>(ctx, T::getTypeID());
+  }
+
   /// Register a parametric type instance T with the uniquer.
+  /// The use of this method is in general discouraged in favor of
+  /// 'registerType<T>(ctx)'.
   template <typename T>
   static typename std::enable_if_t<
       !std::is_same<typename T::ImplType, TypeStorage>::value>
-  registerType(MLIRContext *ctx) {
+  registerType(MLIRContext *ctx, TypeID typeID) {
     ctx->getTypeUniquer().registerParametricStorageType<typename T::ImplType>(
-        T::getTypeID());
+        typeID);
   }
   /// Register a singleton type instance T with the uniquer.
+  /// The use of this method is in general discouraged in favor of
+  /// 'registerType<T>(ctx)'.
   template <typename T>
   static typename std::enable_if_t<
       std::is_same<typename T::ImplType, TypeStorage>::value>
-  registerType(MLIRContext *ctx) {
+  registerType(MLIRContext *ctx, TypeID typeID) {
     ctx->getTypeUniquer().registerSingletonStorageType<TypeStorage>(
-        T::getTypeID(), [&](TypeStorage *storage) {
-          storage->initialize(AbstractType::lookup(T::getTypeID(), ctx));
+        typeID, [&ctx, typeID](TypeStorage *storage) {
+          storage->initialize(AbstractType::lookup(typeID, ctx));
         });
   }
 };
 } // namespace detail
 
 } // end namespace mlir
 
 #endif

mlir/include/mlir/TableGen/Dialect.h

public:
   bool hasRegionArgAttrVerify() const;
 
   /// Returns true if this dialect has a region result attribute verifier.
   bool hasRegionResultAttrVerify() const;
 
   /// Returns true if this dialect has fallback interfaces for its operations.
   bool hasOperationInterfaceFallback() const;
 
+  /// Returns true if this dialect can be extended at runtime with new
+  /// operations or types.
+  bool isExtensible() const;
+
   // Returns whether two dialects are equal by checking the equality of the
   // underlying record.
   bool operator==(const Dialect &other) const;
 
   bool operator!=(const Dialect &other) const { return !(*this == other); }
 
   // Compares two dialects by comparing the names of the dialects.
   bool operator<(const Dialect &other) const;

mlir/lib/IR/CMakeLists.txt

 add_mlir_library(MLIRIR
   AffineExpr.cpp
   AffineMap.cpp
   AsmPrinter.cpp
   Attributes.cpp
   Block.cpp
   Builders.cpp
   BuiltinAttributeInterfaces.cpp
   BuiltinAttributes.cpp
   BuiltinDialect.cpp
   BuiltinTypes.cpp
   Diagnostics.cpp
   Dialect.cpp
   Dominance.cpp
+  ExtensibleDialect.cpp
   FunctionImplementation.cpp
   FunctionSupport.cpp
   IntegerSet.cpp
   Location.cpp
   MLIRContext.cpp
   Operation.cpp
   OperationSupport.cpp
   PatternMatch.cpp

mlir/lib/IR/ExtensibleDialect.cpp

+//===- ExtensibleDialect.cpp - Extensible dialect ---------------*- C++ -*-===//
+//
+// This file is licensed 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Dialects that can register new operations/types/attributes at runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/IR/ExtensibleDialect.h"
+#include "mlir/IR/AttributeSupport.h"
+#include "mlir/IR/DialectImplementation.h"
+#include "mlir/IR/Identifier.h"
+#include "mlir/Support/LogicalResult.h"
+
+using namespace mlir;
+
+//===----------------------------------------------------------------------===//
+// Dynamic types and attributes shared functions
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// Default parser for dynamic attribute or type parameters.
+/// Parse in the format '(<>)?' or '<attr (,attr)*>'.
+LogicalResult typeOrAttrParser(DialectAsmParser &parser,
+                               llvm::SmallVectorImpl<Attribute> &parsedParams) {
+  // No parameters
+  if (parser.parseOptionalLess() || !parser.parseOptionalGreater())
+    return success();
+
+  Attribute attr;
+  if (parser.parseAttribute(attr))
+    return failure();
+  parsedParams.push_back(attr);
+
+  while (parser.parseOptionalGreater()) {
+    Attribute attr;
+    if (parser.parseComma() || parser.parseAttribute(attr))
+      return failure();
+    parsedParams.push_back(attr);
+  }
+
+  return success();
+}
+
+/// Default printer for dynamic attribute or type parameters.
+/// Print in the format '(<>)?' or '<attr (,attr)*>'.
+void typeOrAttrPrinter(DialectAsmPrinter &printer, ArrayRef<Attribute> params) {
+  if (params.empty())
+    return;
+
+  printer << "<";
+  llvm::interleaveComma(params, printer.getStream());
+  printer << ">";
+}
+} // namespace
+
+//===----------------------------------------------------------------------===//
+// Dynamic type
+//===----------------------------------------------------------------------===//
+
+std::unique_ptr<DynamicTypeDefinition>
+DynamicTypeDefinition::get(llvm::StringRef name, Dialect *dialect,
+                           VerifierFn &&verifier) {
+  auto *typeDef = new DynamicTypeDefinition(dialect, name);
+
+  typeDef->verifier = std::move(verifier);
+  typeDef->parser = typeOrAttrParser;
+  typeDef->printer = typeOrAttrPrinter;
+
+  return std::unique_ptr<DynamicTypeDefinition>(typeDef);
+}
+
+std::unique_ptr<DynamicTypeDefinition>
+DynamicTypeDefinition::get(llvm::StringRef name, Dialect *dialect,
+                           VerifierFn &&verifier, ParserFn &&parser,
+                           PrinterFn &&printer) {
+  return std::unique_ptr<DynamicTypeDefinition>(
+      new DynamicTypeDefinition(name, dialect, std::move(verifier),
+                                std::move(parser), std::move(printer)));
+}
+
+DynamicTypeDefinition::DynamicTypeDefinition(llvm::StringRef nameRef,
+                                             Dialect *dialect,
+                                             VerifierFn &&verifier,
+                                             ParserFn &&parser,
+                                             PrinterFn &&printer)
+    : name(nameRef), dialect(dialect), verifier(std::move(verifier)),
+      parser(std::move(parser)), printer(std::move(printer)),
+      typeID(dialect->getContext()->allocateTypeID()),
+      ctx(dialect->getContext()) {
+  assert(!nameRef.contains('.') &&
+         "name should not be prefixed by the dialect name");
+}
+
+DynamicTypeDefinition::DynamicTypeDefinition(Dialect *dialect,
+                                             llvm::StringRef nameRef)
+    : name(nameRef), dialect(dialect),
+      typeID(dialect->getContext()->allocateTypeID()),
+      ctx(dialect->getContext()) {
+  assert(!nameRef.contains('.') &&
+         "name should not be prefixed by the dialect name");
+}
+
+void DynamicTypeDefinition::registerInTypeUniquer() {
+  detail::TypeUniquer::registerType<DynamicType>(&getContext(), getTypeID());
+}
+
+namespace mlir {
+namespace detail {
+/// Storage of DynamicType.
+/// Contains a pointer to the type definition and type parameters.
+struct DynamicTypeStorage : public TypeStorage {
+
+  using KeyTy = std::pair<DynamicTypeDefinition *, ArrayRef<Attribute>>;
+
+  explicit DynamicTypeStorage(DynamicTypeDefinition *typeDef,
+                              ArrayRef<Attribute> params)
+      : typeDef(typeDef), params(params) {}
+
+  bool operator==(const KeyTy &key) const {
+    return typeDef == key.first && params == key.second;
+  }
+
+  static llvm::hash_code hashKey(const KeyTy &key) {
+    return llvm::hash_value(key);
+  }
+
+  static DynamicTypeStorage *construct(TypeStorageAllocator &alloc,
+                                       const KeyTy &key) {
+    return new (alloc.allocate<DynamicTypeStorage>())
+        DynamicTypeStorage(key.first, alloc.copyInto(key.second));
+  }
+
+  /// Definition of the type.
+  DynamicTypeDefinition *typeDef;
+
+  /// The type parameters.
+  ArrayRef<Attribute> params;
+};
+} // namespace detail
+} // namespace mlir
+
+DynamicType DynamicType::get(DynamicTypeDefinition *typeDef,
+                             ArrayRef<Attribute> params) {
+  auto &ctx = typeDef->getContext();
+  return detail::TypeUniquer::getWithTypeID<DynamicType>(
+      &ctx, typeDef->getTypeID(), typeDef, params);
+}
+
+DynamicType
+DynamicType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                        DynamicTypeDefinition *typeDef,
+                        ArrayRef<Attribute> params) {
+  if (failed(typeDef->verify(emitError, params)))
+    return {};
+  return get(typeDef, params);
+}
+
+DynamicTypeDefinition *DynamicType::getTypeDef() { return getImpl()->typeDef; }
+
+ArrayRef<Attribute> DynamicType::getParams() { return getImpl()->params; }
+
+bool DynamicType::classof(Type type) {
+  return type.hasTrait<IsDynamicTypeTrait>();
+}
+
+ParseResult DynamicType::parse(DialectAsmParser &parser,
+                               DynamicTypeDefinition *typeDef,
+                               DynamicType &parsedType) {
+  llvm::SmallVector<Attribute> params;
+  if (failed(typeDef->parser(parser, params)))
+    return failure();
+  auto emitError = [&]() {
+    return parser.emitError(parser.getCurrentLocation());
+  };
+  parsedType = DynamicType::getChecked(emitError, typeDef, params);
+  return success();
+}
+
+void DynamicType::print(DialectAsmPrinter &printer) {
+  printer << getTypeDef()->getName();
+  getTypeDef()->printer(printer, getParams());
+}
+
+//===----------------------------------------------------------------------===//
+// Dynamic attribute
+//===----------------------------------------------------------------------===//
+
+std::unique_ptr<DynamicAttrDefinition>
+DynamicAttrDefinition::get(llvm::StringRef name, Dialect *dialect,
+                           VerifierFn &&verifier) {
+  auto *attrDef = new DynamicAttrDefinition(dialect, name);
+
+  attrDef->verifier = std::move(verifier);
+  attrDef->parser = typeOrAttrParser;
+  attrDef->printer = typeOrAttrPrinter;
+
+  return std::unique_ptr<DynamicAttrDefinition>(attrDef);
+}
+
+std::unique_ptr<DynamicAttrDefinition>
+DynamicAttrDefinition::get(llvm::StringRef name, Dialect *dialect,
+                           VerifierFn &&verifier, ParserFn &&parser,
+                           PrinterFn &&printer) {
+  return std::unique_ptr<DynamicAttrDefinition>(
+      new DynamicAttrDefinition(name, dialect, std::move(verifier),
+                                std::move(parser), std::move(printer)));
+}
+
+DynamicAttrDefinition::DynamicAttrDefinition(llvm::StringRef nameRef,
+                                             Dialect *dialect,
+                                             VerifierFn &&verifier,
+                                             ParserFn &&parser,
+                                             PrinterFn &&printer)
+    : name(nameRef), dialect(dialect), verifier(std::move(verifier)),
+      parser(std::move(parser)), printer(std::move(printer)),
+      typeID(dialect->getContext()->allocateTypeID()),
+      ctx(dialect->getContext()) {
+  assert(!nameRef.contains('.') &&
+         "name should not be prefixed by the dialect name");
+}
+
+DynamicAttrDefinition::DynamicAttrDefinition(Dialect *dialect,
+                                             llvm::StringRef nameRef)
+    : name(nameRef), dialect(dialect),
+      typeID(dialect->getContext()->allocateTypeID()),
+      ctx(dialect->getContext()) {
+  assert(!nameRef.contains('.') &&
+         "name should not be prefixed by the dialect name");
+}
+
+void DynamicAttrDefinition::registerInAttrUniquer() {
+  detail::AttributeUniquer::registerAttribute<DynamicAttr>(&getContext(), getTypeID());
+}
+
+namespace mlir {
+namespace detail {
+/// Storage of DynamicAttr.
+/// Contains a pointer to the attribute definition and attribute parameters.
+struct DynamicAttrStorage : public AttributeStorage {
+
+  using KeyTy = std::pair<DynamicAttrDefinition *, ArrayRef<Attribute>>;
+
+  explicit DynamicAttrStorage(DynamicAttrDefinition *attrDef,
+                              ArrayRef<Attribute> params)
+      : attrDef(attrDef), params(params) {}
+
+  bool operator==(const KeyTy &key) const {
+    return attrDef == key.first && params == key.second;
+  }
+
+  static llvm::hash_code hashKey(const KeyTy &key) {
+    return llvm::hash_value(key);
+  }
+
+  static DynamicAttrStorage *construct(AttributeStorageAllocator &alloc,
+                                       const KeyTy &key) {
+    return new (alloc.allocate<DynamicAttrStorage>())
+        DynamicAttrStorage(key.first, alloc.copyInto(key.second));
+  }
+
+  /// Definition of the type.
+  DynamicAttrDefinition *attrDef;
+
+  /// The type parameters.
+  ArrayRef<Attribute> params;
+};
+} // namespace detail
+} // namespace mlir
+
+DynamicAttr DynamicAttr::get(DynamicAttrDefinition *attrDef,
+                             ArrayRef<Attribute> params) {
+  auto &ctx = attrDef->getContext();
+  return detail::AttributeUniquer::getWithTypeID<DynamicAttr>(
+      &ctx, attrDef->getTypeID(), attrDef, params);
+}
+
+DynamicAttr
+DynamicAttr::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                        DynamicAttrDefinition *attrDef,
+                        ArrayRef<Attribute> params) {
+  if (failed(attrDef->verify(emitError, params)))
+    return {};
+  return get(attrDef, params);
+}
+
+DynamicAttrDefinition *DynamicAttr::getAttrDef() { return getImpl()->attrDef; }
+
+ArrayRef<Attribute> DynamicAttr::getParams() { return getImpl()->params; }
+
+bool DynamicAttr::classof(Attribute attr) {
+  return attr.hasTrait<IsDynamicAttrTrait>();
+}
+
+ParseResult DynamicAttr::parse(DialectAsmParser &parser,
+                               DynamicAttrDefinition *attrDef,
+                               DynamicAttr &parsedAttr) {
+  llvm::SmallVector<Attribute> params;
+  if (failed(attrDef->parser(parser, params)))
+    return failure();
+  auto emitError = [&]() {
+    return parser.emitError(parser.getCurrentLocation());
+  };
+  parsedAttr = DynamicAttr::getChecked(emitError, attrDef, params);
+  return success();
+}
+
+void DynamicAttr::print(DialectAsmPrinter &printer) {
+  printer << getAttrDef()->getName();
+  getAttrDef()->printer(printer, getParams());
+}
+
+//===----------------------------------------------------------------------===//
+// Dynamic operation
+//===----------------------------------------------------------------------===//
+
+DynamicOpDefinition::DynamicOpDefinition(
+    StringRef name, Dialect *dialect,
+    AbstractOperation::VerifyInvariantsFn &&verifyFn,
+    AbstractOperation::ParseAssemblyFn &&parseFn,
+    AbstractOperation::PrintAssemblyFn &&printFn,
+    AbstractOperation::FoldHookFn &&foldHookFn,
+    AbstractOperation::GetCanonicalizationPatternsFn
+        &&getCanonicalizationPatternsFn)
+    : typeID(dialect->getContext()->allocateTypeID()),
+      name((dialect->getNamespace() + "." + name).str()), dialect(dialect),
+      verifyFn(std::move(verifyFn)), parseFn(std::move(parseFn)),
+      printFn(std::move(printFn)), foldHookFn(std::move(foldHookFn)),
+      getCanonicalizationPatternsFn(std::move(getCanonicalizationPatternsFn)) {
+  assert(!name.contains('.') &&
+         "name should not be prefixed by the dialect name");
+}
+
+std::unique_ptr<DynamicOpDefinition>
+DynamicOpDefinition::get(StringRef name, Dialect *dialect,
+                         AbstractOperation::VerifyInvariantsFn &&verifyFn) {
+  auto parseFn = [](OpAsmParser &parser, OperationState &result) {
+    parser.emitError(parser.getCurrentLocation(),
+                     "dynamic operation do not define any parser function");
+    return failure();
+  };
+
+  auto printFn = [](Operation *op, OpAsmPrinter &printer, StringRef) {
+    printer.printGenericOp(op);
+  };
+
+  return DynamicOpDefinition::get(name, dialect, std::move(verifyFn),
+                                  std::move(parseFn), std::move(printFn));
+}
+
+std::unique_ptr<DynamicOpDefinition>
+DynamicOpDefinition::get(StringRef name, Dialect *dialect,
+                         AbstractOperation::VerifyInvariantsFn &&verifyFn,
+                         AbstractOperation::ParseAssemblyFn &&parseFn,
+                         AbstractOperation::PrintAssemblyFn &&printFn) {
+  auto foldHookFn = [](mlir::Operation *op,
+                       llvm::ArrayRef<mlir::Attribute> operands,
+                       llvm::SmallVectorImpl<mlir::OpFoldResult> &results) {
+    return failure();
+  };
+
+  auto getCanonicalizationPatternsFn = [](OwningRewritePatternList &,
+                                          MLIRContext *) {};
+
+  return DynamicOpDefinition::get(name, dialect, std::move(verifyFn),
+                                  std::move(parseFn), std::move(printFn),
+                                  std::move(foldHookFn),
+                                  std::move(getCanonicalizationPatternsFn));
+}
+
+std::unique_ptr<DynamicOpDefinition>
+DynamicOpDefinition::get(StringRef name, Dialect *dialect,
+                         AbstractOperation::VerifyInvariantsFn &&verifyFn,
+                         AbstractOperation::ParseAssemblyFn &&parseFn,
+                         AbstractOperation::PrintAssemblyFn &&printFn,
+                         AbstractOperation::FoldHookFn &&foldHookFn,
+                         AbstractOperation::GetCanonicalizationPatternsFn
+                             &&getCanonicalizationPatternsFn) {
+  return std::unique_ptr<DynamicOpDefinition>(new DynamicOpDefinition(
+      name, dialect, std::move(verifyFn), std::move(parseFn),
+      std::move(printFn), std::move(foldHookFn),
+      std::move(getCanonicalizationPatternsFn)));
+}
+
+//===----------------------------------------------------------------------===//
+// Extensible dialect
+//===----------------------------------------------------------------------===//
+
+/// Interface that can only be implemented by extensible dialects.
+/// The interface is used to check if a dialect is extensible or not.
+class IsExtensibleDialect : public DialectInterface::Base<IsExtensibleDialect> {
+public:
+  IsExtensibleDialect(Dialect *dialect) : Base(dialect) {}
+};
+
+ExtensibleDialect::ExtensibleDialect(StringRef name, MLIRContext *ctx,
+                                     TypeID typeID)
+    : Dialect(Identifier::get(name, ctx), ctx, typeID) {
+  addInterfaces<IsExtensibleDialect>();
+}
+
+void ExtensibleDialect::addDynamicType(
+    std::unique_ptr<DynamicTypeDefinition> &&type) {
+  auto *typePtr = type.get();
+  auto typeID = type->getTypeID();
+  auto name = type->getName();
+  auto *dialect = type->getDialect();
+
+  assert(dialect == this &&
+         "trying to register a dynamic type in the wrong dialect");
+
+  // If a type with the same name is already defined, fail.
+  auto registered = dynTypes.try_emplace(typeID, std::move(type)).second;
+  assert(registered && "type TypeID was not unique");
+
+  registered = nameToDynTypes.insert({name, typePtr}).second;
+  assert(registered &&
+         "Trying to create a new dynamic type with an existing name");
+
+  auto abstractType =
+      AbstractType::get(*dialect, DynamicAttr::getInterfaceMap(),
+                        DynamicType::getHasTraitFn(), typeID);
+
+  /// Add the type to the dialect and the type uniquer.
+  addType(typeID, std::move(abstractType));
+  typePtr->registerInTypeUniquer();
+}
+
+void ExtensibleDialect::addDynamicAttr(
+    std::unique_ptr<DynamicAttrDefinition> &&attr) {
+  auto *attrPtr = attr.get();
+  auto typeID = attr->getTypeID();
+  auto name = attr->getName();
+  auto *dialect = attr->getDialect();
+
+  assert(dialect == this &&
+         "trying to register a dynamic attribute in the wrong dialect");
+
+  // If an attribute with the same name is already defined, fail.
+  auto registered = dynAttrs.try_emplace(typeID, std::move(attr)).second;
+  assert(registered && "attribute TypeID was not unique");
+
+  registered = nameToDynAttrs.insert({name, attrPtr}).second;
+  assert(registered &&
+         "Trying to create a new dynamic attribute with an existing name");
+
+  auto abstractAttr =
+      AbstractAttribute::get(*dialect, DynamicAttr::getInterfaceMap(),
+                             DynamicAttr::getHasTraitFn(), typeID);
+
+  /// Add the type to the dialect and the type uniquer.
+  addAttribute(typeID, std::move(abstractAttr));
+  attrPtr->registerInAttrUniquer();
+}
+
+void ExtensibleDialect::addDynamicOp(
+    std::unique_ptr<DynamicOpDefinition> &&op) {
+  assert(op->dialect == this &&
+         "trying to register a dynamic op in the wrong dialect");
+  auto hasTraitFn = [](TypeID traitId) { return false; };
+
+  AbstractOperation::insert(
+      op->name, *op->dialect, op->typeID, std::move(op->parseFn),
+      std::move(op->printFn), std::move(op->verifyFn),
+      std::move(op->foldHookFn), std::move(op->getCanonicalizationPatternsFn),
+      detail::InterfaceMap::get<>(), std::move(hasTraitFn), {});
+}
+
+bool ExtensibleDialect::classof(const Dialect *dialect) {
+  return const_cast<Dialect *>(dialect)
+      ->getRegisteredInterface<IsExtensibleDialect>();
+}
+
+OptionalParseResult ExtensibleDialect::parseOptionalDynamicType(
+    StringRef typeName, DialectAsmParser &parser, Type &resultType) const {
+  auto *typeDef = lookupTypeDefinition(typeName);
+  if (typeDef) {
+    DynamicType dynType;
+    if (DynamicType::parse(parser, typeDef, dynType))
+      return failure();
+    resultType = dynType;
+    return {success()};
+  }
+
+  return {};
+}
+
+LogicalResult
+ExtensibleDialect::printIfDynamicType(Type type, DialectAsmPrinter &printer) {
+  if (auto dynType = type.dyn_cast<DynamicType>()) {
+    dynType.print(printer);
+    return success();
+  }
+  return failure();
+}
+
+OptionalParseResult ExtensibleDialect::parseOptionalDynamicAttr(
+    StringRef attrName, DialectAsmParser &parser, Attribute &resultAttr) const {
+  auto *attrDef = lookupAttrDefinition(attrName);
+  if (attrDef) {
+    DynamicAttr dynAttr;
+    if (DynamicAttr::parse(parser, attrDef, dynAttr))
+      return failure();
+    resultAttr = dynAttr;
+    return {success()};
+  }
+
+  return {};
+}
+
+LogicalResult
+ExtensibleDialect::printIfDynamicAttr(Attribute attribute,
+                                      DialectAsmPrinter &printer) {
+  if (auto dynAttr = attribute.dyn_cast<DynamicAttr>()) {
+    dynAttr.print(printer);
+    return success();
+  }
+  return failure();
+}

mlir/lib/TableGen/Dialect.cpp

 bool Dialect::hasRegionResultAttrVerify() const {
   return def->getValueAsBit("hasRegionResultAttrVerify");
 }
 
 bool Dialect::hasOperationInterfaceFallback() const {
   return def->getValueAsBit("hasOperationInterfaceFallback");
 }
 
+bool Dialect::isExtensible() const {
+  return def->getValueAsBit("isExtensible");
+}
+
 bool Dialect::operator==(const Dialect &other) const {
   return def == other.def;
 }
 
 bool Dialect::operator<(const Dialect &other) const {
   return getName() < other.getName();
 }

mlir/test/IR/dynamic.mlir

+// RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -verify-diagnostics | FileCheck %s
+// Verify that extensible dialects can register dynamic operations and types.
+
+//===----------------------------------------------------------------------===//
+// Dynamic type
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: func @succeededDynamicTypeVerifier
+func @succeededDynamicTypeVerifier() {
+  // CHECK: %{{.*}} = "unregistered_op"() : () -> !test.singleton_dyntype
+  "unregistered_op"() : () -> !test.singleton_dyntype
+  // CHECK-NEXT: "unregistered_op"() : () -> !test.pair_dyntype<i32, f64>
+  "unregistered_op"() : () -> !test.pair_dyntype<i32, f64>
+  // CHECK_NEXT: %{{.*}} = "unregistered_op"() : () -> !test.pair_dyntype<!test.pair_dyntype<i32, f64>, !test.singleton_dyntype>
+  "unregistered_op"() : () -> !test.pair_dyntype<!test.pair_dyntype<i32, f64>, !test.singleton_dyntype>
+  return
+}
+
+// -----
+
+func @failedDynamicTypeVerifier() {
+  // expected-error@+1 {{expected 0 type arguments, but had 1}}
+  "unregistered_op"() : () -> !test.singleton_dyntype<f64>
+  return
+}
+
+// -----
+
+func @failedDynamicTypeVerifier2() {
+  // expected-error@+1 {{expected 2 type arguments, but had 1}}
+  "unregistered_op"() : () -> !test.pair_dyntype<f64>
+  return
+}
+
+// -----
+
+// CHECK-LABEL: func @customTypeParserPrinter
+func @customTypeParserPrinter() {
+  // CHECK: "unregistered_op"() : () -> !test.custom_assembly_format_dyntype<f32:f64>
+  "unregistered_op"() : () -> !test.custom_assembly_format_dyntype<f32 : f64>
+  return
+}
+
+//===----------------------------------------------------------------------===//
+// Dynamic attribute
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: func @succeededDynamicAttributeVerifier
+func @succeededDynamicAttributeVerifier() {
+  // CHECK: "unregistered_op"() {test_attr = #test.singleton_dynattr} : () -> ()
+  "unregistered_op"() {test_attr = #test.singleton_dynattr} : () -> ()
+  // CHECK-NEXT: "unregistered_op"() {test_attr = #test.pair_dynattr<3 : i32, 5 : i32>} : () -> ()
+  "unregistered_op"() {test_attr = #test.pair_dynattr<3 : i32, 5 : i32>} : () -> ()
+  // CHECK_NEXT: "unregistered_op"() {test_attr = #test.pair_dynattr<3 : i32, 5 : i32>} : () -> ()
+  "unregistered_op"() {test_attr = #test.pair_dynattr<#test.pair_dynattr<3 : i32, 5 : i32>, f64>} : () -> ()
+  return
+}
+
+// -----
+
+func @failedDynamicAttributeVerifier() {
+  // expected-error@+1 {{expected 0 attribute arguments, but had 1}}
+  "unregistered_op"() {test_attr = #test.singleton_dynattr<f64>} : () -> ()
+  return
+}
+
+// -----
+
+func @failedDynamicAttributeVerifier2() {
+  // expected-error@+1 {{expected 2 attribute arguments, but had 1}}
+  "unregistered_op"() {test_attr = #test.pair_dynattr<f64> : () -> ()
+  return
+}
+
+// -----
+
+// CHECK-LABEL: func @customAttributeParserPrinter
+func @customAttributeParserPrinter() {
+  // CHECK: "unregistered_op"() {test_attr = #test.custom_assembly_format_dynattr<f32:f64>} : () -> ()
+  "unregistered_op"() {test_attr = #test.custom_assembly_format_dynattr<f32:f64>} : () -> ()
+  return
+}
+
+//===----------------------------------------------------------------------===//
+// Dynamic op
+//===----------------------------------------------------------------------===//
+
+// -----
+
+// CHECK-LABEL: func @succeededDynamicOpVerifier
+func @succeededDynamicOpVerifier(%a: f32) {
+  // CHECK: "test.generic_dynamic_op"() : () -> ()
+  // CHECK-NEXT: %{{.*}} = "test.generic_dynamic_op"(%{{.*}}) : (f32) -> f64
+  // CHECK-NEXT: %{{.*}}:2 = "test.one_operand_two_results"(%{{.*}}) : (f32) -> (f64, f64)
+  "test.generic_dynamic_op"() : () -> ()
+  "test.generic_dynamic_op"(%a) : (f32) -> f64
+  "test.one_operand_two_results"(%a) : (f32) -> (f64, f64)
+  return
+}
+
+// -----
+
+func @failedDynamicOpVerifier() {
+  // expected-error@+1 {{expected 1 operand, but had 0}}
+  "test.one_operand_two_results"() : () -> (f64, f64)
+  return
+}
+
+// -----
+
+func @failedDynamicOpVerifier2(%a: f32) {
+  // expected-error@+1 {{expected 2 results, but had 0}}
+  "test.one_operand_two_results"(%a) : (f32) -> ()
+  return
+}
+
+// -----
+
+// CHECK-LABEL: func @customOpParserPrinter
+func @customOpParserPrinter() {
+  // CHECK: test.custom_parser_printer_dynamic_op custom_keyword
+  test.custom_parser_printer_dynamic_op custom_keyword
+  return
+}

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

 // features of MLIR.
 //
 //===----------------------------------------------------------------------===//
 
 #include "TestAttributes.h"
 #include "TestDialect.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/DialectImplementation.h"
+#include "mlir/IR/ExtensibleDialect.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
 using namespace test;
 

 //===----------------------------------------------------------------------===//
 
 #include "TestAttrInterfaces.cpp.inc"
 
 #define GET_ATTRDEF_CLASSES
 #include "TestAttrDefs.cpp.inc"
 
 //===----------------------------------------------------------------------===//
+// Dynamic Attributes
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// Define a singleton dynamic attribute.
+std::unique_ptr<DynamicAttrDefinition>
+getSingletonDynamicAttr(Dialect *testDialect) {
+  return DynamicAttrDefinition::get(
+      "singleton_dynattr", testDialect,
+      [](function_ref<InFlightDiagnostic()> emitError,
+         ArrayRef<Attribute> args) {
+        if (!args.empty()) {
+          emitError() << "expected 0 attribute arguments, but had "
+                      << args.size();
+          return failure();
+        }
+        return success();
+      });
+}
+
+/// Define a dynamic attribute representing a pair or attributes.
+std::unique_ptr<DynamicAttrDefinition>
+getPairDynamicAttr(Dialect *testDialect) {
+  return DynamicAttrDefinition::get(
+      "pair_dynattr", testDialect,
+      [](function_ref<InFlightDiagnostic()> emitError,
+         ArrayRef<Attribute> args) {
+        if (args.size() != 2) {
+          emitError() << "expected 2 attribute arguments, but had "
+                      << args.size();
+          return failure();
+        }
+        return success();
+      });
+}
+
+std::unique_ptr<DynamicAttrDefinition>
+getCustomAssemblyFormatDynamicAttr(Dialect *testDialect) {
+  auto verifier = [](function_ref<InFlightDiagnostic()> emitError,
+                     ArrayRef<Attribute> args) {
+    if (args.size() != 2) {
+      emitError() << "expected 2 attribute arguments, but had " << args.size();
+      return failure();
+    }
+    return success();
+  };
+
+  auto parser = [](DialectAsmParser &parser,
+                   llvm::SmallVectorImpl<Attribute> &parsedParams) {
+    Attribute leftAttr, rightAttr;
+    if (parser.parseLess() || parser.parseAttribute(leftAttr) ||
+        parser.parseColon() || parser.parseAttribute(rightAttr) ||
+        parser.parseGreater())
+      return failure();
+    parsedParams.push_back(leftAttr);
+    parsedParams.push_back(rightAttr);
+    return success();
+  };
+
+  auto printer = [](DialectAsmPrinter &printer, ArrayRef<Attribute> params) {
+    printer << "<" << params[0] << ":" << params[1] << ">";
+  };
+
+  return DynamicAttrDefinition::get("custom_assembly_format_dynattr",
+                                    testDialect, std::move(verifier),
+                                    std::move(parser), std::move(printer));
+}
+} // namespace
+
+//===----------------------------------------------------------------------===//
 // TestDialect
 //===----------------------------------------------------------------------===//
 
 void TestDialect::registerAttributes() {
   addAttributes<
 #define GET_ATTRDEF_LIST
 #include "TestAttrDefs.cpp.inc"
       >();
+  addDynamicAttr(getSingletonDynamicAttr(this));
+  addDynamicAttr(getPairDynamicAttr(this));
+  addDynamicAttr(getCustomAssemblyFormatDynamicAttr(this));
 }
 
 Attribute TestDialect::parseAttribute(DialectAsmParser &parser,
                                       Type type) const {
   StringRef attrTag;
   if (failed(parser.parseKeyword(&attrTag)))
     return Attribute();
   {
     Attribute attr;
     auto parseResult = generatedAttributeParser(parser, attrTag, type, attr);
     if (parseResult.hasValue())
       return attr;
   }
+
+  {
+    Attribute dynAttr;
+    auto parseResult = parseOptionalDynamicAttr(attrTag, parser, dynAttr);
+    if (parseResult.hasValue()) {
+      if (succeeded(parseResult.getValue()))
+        return dynAttr;
+      return Attribute();
+    }
+  }
+
   parser.emitError(parser.getNameLoc(), "unknown test attribute");
   return Attribute();
 }
 
 void TestDialect::printAttribute(Attribute attr,
                                  DialectAsmPrinter &printer) const {
   if (succeeded(generatedAttributePrinter(attr, printer)))
     return;
+
+  if (succeeded(printIfDynamicAttr(attr, printer)))
+    return;
+
+  assert(false && "unknown test attribute");
 }

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

 #include "TestInterfaces.h"
 #include "mlir/Dialect/DLTI/DLTI.h"
 #include "mlir/Dialect/DLTI/Traits.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Traits.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
+#include "mlir/IR/ExtensibleDialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/RegionKindInterface.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/CopyOpInterface.h"
 #include "mlir/Interfaces/DerivedAttributeOpInterface.h"

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

 #include "TestAttributes.h"
 #include "TestInterfaces.h"
 #include "TestTypes.h"
 #include "mlir/Dialect/DLTI/DLTI.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/DialectImplementation.h"
+#include "mlir/IR/ExtensibleDialect.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Reducer/ReductionPatternInterface.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/InliningUtils.h"
 #include "llvm/ADT/StringSwitch.h"
 
 // Include this before the using namespace lines below to
public:
   void populateReductionPatterns(RewritePatternSet &patterns) const final {
     populateTestReductionPatterns(patterns);
   }
 };
 
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
+// Dynamic operations
+//===----------------------------------------------------------------------===//
+
+std::unique_ptr<DynamicOpDefinition> getGenericDynamicOp(Dialect *dialect) {
+  return DynamicOpDefinition::get("generic_dynamic_op", dialect,
+                                  [](Operation *op) { return success(); });
+}
+
+std::unique_ptr<DynamicOpDefinition>
+getOneOperandTwoResultsDynamicOp(Dialect *dialect) {
+  return DynamicOpDefinition::get(
+      "one_operand_two_results", dialect, [](Operation *op) {
+        if (op->getNumOperands() != 1) {
+          op->emitOpError()
+              << "expected 1 operand, but had " << op->getNumOperands();
+          return failure();
+        }
+        if (op->getNumResults() != 2) {
+          op->emitOpError()
+              << "expected 2 results, but had " << op->getNumResults();
+          return failure();
+        }
+        return success();
+      });
+}
+
+std::unique_ptr<DynamicOpDefinition>
+getCustomParserPrinterDynamicOp(Dialect *dialect) {
+  auto verifier = [](Operation *op) {
+    if (op->getNumOperands() == 0 && op->getNumResults() == 0)
+      return success();
+    op->emitError() << "operation should have no operands and no results";
+    return failure();
+  };
+
+  auto parser = [](OpAsmParser &parser, OperationState &state) {
+    return parser.parseKeyword("custom_keyword");
+  };
+
+  auto printer = [](Operation *op, OpAsmPrinter &printer, llvm::StringRef) {
+    printer << op->getName() << " custom_keyword";
+  };
+
+  return DynamicOpDefinition::get("custom_parser_printer_dynamic_op", dialect,
+                                  verifier, parser, printer);
+}
+
+//===----------------------------------------------------------------------===//
 // TestDialect
 //===----------------------------------------------------------------------===//
 
 static void testSideEffectOpGetEffect(
     Operation *op,
     SmallVectorImpl<SideEffects::EffectInstance<TestEffects::Effect>> &effects);
 
 // This is the implementation of a dialect fallback for `TestEffectOpInterface`.

 
 void TestDialect::initialize() {
   registerAttributes();
   registerTypes();
   addOperations<
 #define GET_OP_LIST
 #include "TestOps.cpp.inc"
       >();
+  addDynamicOp(getGenericDynamicOp(this));
+  addDynamicOp(getOneOperandTwoResultsDynamicOp(this));
+  addDynamicOp(getCustomParserPrinterDynamicOp(this));
+
   addInterfaces<TestOpAsmInterface, TestDialectFoldInterface,
                 TestInlinerInterface, TestReductionPatternInterface>();
   allowUnknownOperations();
 
   // Instantiate our fallback op interface that we'll use on specific
   // unregistered op.
   fallbackEffectOpInterfaces = new TestOpEffectInterfaceFallback;
 }

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

def Test_Dialect : Dialect {
   let cppNamespace = "::test";
   let hasCanonicalizer = 1;
   let hasConstantMaterializer = 1;
   let hasOperationAttrVerify = 1;
   let hasRegionArgAttrVerify = 1;
   let hasRegionResultAttrVerify = 1;
   let hasOperationInterfaceFallback = 1;
   let hasNonDefaultDestructor = 1;
+  let isExtensible = 1;
   let dependentDialects = ["::mlir::DLTIDialect"];
 
   let extraClassDeclaration = [{
     void registerAttributes();
     void registerTypes();
 
     ::mlir::Attribute parseAttribute(::mlir::DialectAsmParser &parser,
                                      ::mlir::Type type) const override;
     void printAttribute(::mlir::Attribute attr,
                         ::mlir::DialectAsmPrinter &printer) const override;
 
     // Provides a custom printing/parsing for some operations.
     ::llvm::Optional<ParseOpHook>
       getParseOperationHook(::llvm::StringRef opName) const override;
     ::llvm::unique_function<void(::mlir::Operation *,
                                  ::mlir::OpAsmPrinter &printer)>
      getOperationPrinter(::mlir::Operation *op) const override;
 
   private:
     // Storage for a custom fallback interface.
     void *fallbackEffectOpInterfaces;
 
+    ::mlir::Type parseTestType(::mlir::DialectAsmParser &parser,
+                               ::llvm::SetVector<::mlir::Type> &stack) const;
+    void printTestType(::mlir::Type type, ::mlir::DialectAsmPrinter &printer,
+                       ::llvm::SetVector<::mlir::Type> &stack) const;
   }];
 }
 
 class TEST_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<Test_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // Test Types

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

 //===----------------------------------------------------------------------===//
 // Tablegen Generated Definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_TYPEDEF_CLASSES
 #include "TestTypeDefs.cpp.inc"
 
 //===----------------------------------------------------------------------===//
+// Dynamic Types
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// Define a singleton dynamic type.
+std::unique_ptr<DynamicTypeDefinition>
+getSingletonDynamicType(Dialect *testDialect) {
+  return DynamicTypeDefinition::get(
+      "singleton_dyntype", testDialect,
+      [](function_ref<InFlightDiagnostic()> emitError,
+         ArrayRef<Attribute> args) {
+        if (!args.empty()) {
+          emitError() << "expected 0 type arguments, but had " << args.size();
+          return failure();
+        }
+        return success();
+      });
+}
+
+/// Define a dynamic type representing a pair.
+std::unique_ptr<DynamicTypeDefinition>
+getPairDynamicType(Dialect *testDialect) {
+  return DynamicTypeDefinition::get(
+      "pair_dyntype", testDialect,
+      [](function_ref<InFlightDiagnostic()> emitError,
+         ArrayRef<Attribute> args) {
+        if (args.size() != 2) {
+          emitError() << "expected 2 type arguments, but had " << args.size();
+          return failure();
+        }
+        return success();
+      });
+}
+
+std::unique_ptr<DynamicTypeDefinition>
+getCustomAssemblyFormatDynamicType(Dialect *testDialect) {
+  auto verifier = [](function_ref<InFlightDiagnostic()> emitError,
+                     ArrayRef<Attribute> args) {
+    if (args.size() != 2) {
+      emitError() << "expected 2 type arguments, but had " << args.size();
+      return failure();
+    }
+    return success();
+  };
+
+  auto parser = [](DialectAsmParser &parser,
+                   llvm::SmallVectorImpl<Attribute> &parsedParams) {
+    Attribute leftAttr, rightAttr;
+    if (parser.parseLess() || parser.parseAttribute(leftAttr) ||
+        parser.parseColon() || parser.parseAttribute(rightAttr) ||
+        parser.parseGreater())
+      return failure();
+    parsedParams.push_back(leftAttr);
+    parsedParams.push_back(rightAttr);
+    return success();
+  };
+
+  auto printer = [](DialectAsmPrinter &printer, ArrayRef<Attribute> params) {
+    printer << "<" << params[0] << ":" << params[1] << ">";
+  };
+
+  return DynamicTypeDefinition::get("custom_assembly_format_dyntype",
+                                    testDialect, std::move(verifier),
+                                    std::move(parser), std::move(printer));
+}
+
+} // namespace
+
+//===----------------------------------------------------------------------===//
 // TestDialect
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 struct PtrElementModel
     : public LLVM::PointerElementTypeInterface::ExternalModel<PtrElementModel,
                                                               SimpleAType> {};
 } // namespace
 
 void TestDialect::registerTypes() {
   addTypes<TestRecursiveType,
 #define GET_TYPEDEF_LIST
 #include "TestTypeDefs.cpp.inc"
            >();
   SimpleAType::attachInterface<PtrElementModel>(*getContext());
+
+  addDynamicType(getSingletonDynamicType(this));
+  addDynamicType(getPairDynamicType(this));
+  addDynamicType(getCustomAssemblyFormatDynamicType(this));
 }
 
-static Type parseTestType(DialectAsmParser &parser, SetVector<Type> &stack) {
+Type TestDialect::parseTestType(DialectAsmParser &parser,
+                                SetVector<Type> &stack) const {
   StringRef typeTag;
   if (failed(parser.parseKeyword(&typeTag)))
     return Type();
 
   {
     Type genType;
     auto parseResult = generatedTypeParser(parser, typeTag, genType);
     if (parseResult.hasValue())
       return genType;
   }
 
+  {
+    Type dynType;
+    auto parseResult = parseOptionalDynamicType(typeTag, parser, dynType);
+    if (parseResult.hasValue()) {
+      if (succeeded(parseResult.getValue()))
+        return dynType;
+      return Type();
+    }
+  }
+
   if (typeTag != "test_rec") {
     parser.emitError(parser.getNameLoc()) << "unknown type!";
     return Type();
   }
 
   StringRef name;
   if (parser.parseLess() || parser.parseKeyword(&name))
     return Type();
Type TestDialect::parseTestType(DialectAsmParser &parser,
   return rec;
 }
 
 Type TestDialect::parseType(DialectAsmParser &parser) const {
   SetVector<Type> stack;
   return parseTestType(parser, stack);
 }
 
-static void printTestType(Type type, DialectAsmPrinter &printer,
-                          SetVector<Type> &stack) {
+void TestDialect::printTestType(Type type, DialectAsmPrinter &printer,
+                                SetVector<Type> &stack) const {
   if (succeeded(generatedTypePrinter(type, printer)))
     return;
 
+  if (succeeded(printIfDynamicType(type, printer)))
+    return;
+
   auto rec = type.cast<TestRecursiveType>();
   printer << "test_rec<" << rec.getName();
   if (!stack.contains(rec)) {
     printer << ", ";
     stack.insert(rec);
     printTestType(rec.getBody(), printer, stack);
     stack.pop_back();
   }
   printer << ">";
 }
 
 void TestDialect::printType(Type type, DialectAsmPrinter &printer) const {
   SetVector<Type> stack;
   printTestType(type, printer, stack);
 }

mlir/tools/mlir-tblgen/DialectGen.cpp

 
 /// The code block for the start of a dialect class declaration.
 ///
 /// {0}: The name of the dialect class.
 /// {1}: The dialect namespace.
 /// {2}: initialization code that is emitted in the ctor body before calling
 /// initialize()
 static const char *const dialectDeclBeginStr = R"(
-class {0} : public ::mlir::Dialect {
+class {0} : public ::mlir::{3} {
   explicit {0}(::mlir::MLIRContext *context)
-    : ::mlir::Dialect(getDialectNamespace(), context,
+    : ::mlir::{3}(getDialectNamespace(), context,
       ::mlir::TypeID::get<{0}>()) {{
     {2}
     initialize();
   }
 
   void initialize();
   friend class ::mlir::MLIRContext;
 public:
static void emitDialectDecl(Dialect &dialect,
   }
 
   // Emit all nested namespaces.
   {
     NamespaceEmitter nsEmitter(os, dialect);
 
     // Emit the start of the decl.
     std::string cppName = dialect.getCppClassName();
+    StringRef superClassName =
+        dialect.isExtensible() ? "ExtensibleDialect" : "Dialect";
     os << llvm::formatv(dialectDeclBeginStr, cppName, dialect.getName(),
-                        dependentDialectRegistrations);
+                        dependentDialectRegistrations, superClassName);
 
     // Check for any attributes/types registered to this dialect.  If there are,
     // add the hooks for parsing/printing.
     if (!dialectAttrs.empty())
       os << attrParserDecl;
     if (!dialectTypes.empty())
       os << typeParserDecl;