[mlir][irdl] Introduce a way to define regions

[unterumarmung]

Summary

This patch introduces new operations:
irdl.region and irdl.regions.
The former lets us to specify characteristics of a region,
such as the arguments for the entry block and the number of blocks.
The latter accepts all results of the former operations
to define the set of the regions for the operation.

Example:

irdl.dialect @example {
  irdl.operation @op_with_regions {
      %r0 = irdl.region
      %r1 = irdl.region()
      %v0 = irdl.is i32
      %v1 = irdl.is i64
      %r2 = irdl.region(%v0, %v1)
      %r3 = irdl.region with size 3

      irdl.regions(%r0, %r1, %r2, %r3)
  }
}

The above snippet demonstrates an operation named @op_with_regions,
which is constrained to have four regions.

• Region %r0 doesn't have any constraints on the arguments or the number of blocks.
• Region %r1 should have an empty set of arguments.
• Region %r2 should have two arguments of types i32 and i64.
• Region %r3 should contain exactly three blocks.

In the future the block count constraint may be expanded to support range of possible number of blocks.

[math-fehr]

That looks like a nice first step to me!
I think the things I would change are:

• Adding an !irdl.region type
• Making that by default, irdl.region do not constrain the number of blocks
• Maybe changing the format of irdl.region to make it explicit that we are constraining the number of arguments to 0 if no arguments are provided

mlir/include/mlir/Dialect/IRDL/IR/IRDLOps.td

357

Can you create a new IRDL_RegionType for that?

434–435

By default, it should not constrain anything.

443

I feel that the syntax here should look like irdl.region() with size 3.
I think it makes it more obvious that we are constraining the number of arguments to be zero. Otherwise, I would think that this means a region with an arbitrary number of arguments.

456

Same here, should be an IRDL_RegionType

mlir/include/mlir/Dialect/IRDL/IRDLVerifiers.h

183

This should not inherit from Constraint.
It should be its own kind of constraint.
However, we do not need to "save" the region characteristics in the ConstraintVerifier I believe.

mlir/lib/Dialect/IRDL/IR/IRDL.cpp

234

We should not by default constraint it to be 1.
I believe that by default, we should not check the region block size.

239–250

This is not needed if you have an IRDL_RegionType

mlir/test/Dialect/IRDL/regions.irdl.mlir

1–2 ↗

(On Diff #539698)

Can you maybe rename the file regions-invalid.irdl.mlir, or something similar?

mlir/test/Dialect/IRDL/testd.mlir

597

Can you add a newline here?

[unterumarmung]

mlir/include/mlir/Dialect/IRDL/IR/IRDLOps.td

434–435

Makes sense

443

So, to clarify:

• irdl.region() should constraint that there are no arguments
• irdl.region should mean that there an arbitrary number of arguments

Right?

The question to me is how to code with with the declarative assemblyFormat? Because either way the entryBlockArgs are gonna be empty
Maybe it should be Optional<Variadic<IRDL_RegionType>>? Or there is a need for a custom parsing to achieve this?

[math-fehr]

mlir/include/mlir/Dialect/IRDL/IR/IRDLOps.td

443

Hmm, I think we would have to have a Variadic<IRDL_RegionType>, and an UnitAttr for that.
I guess that for now we could just write irdl.region() instead, and disallow irdl.region to make things more simple and less ambiguous (and have the code be simpler).

[unterumarmung]

Rebase, fixed some mistakes (probably added new :D)

[unterumarmung]

Hey @math-fehr!

I've just posted the latest work-in-progress version. I've made the changes you requested by implementing the empty parenthesis. It didn't add much complexity with the UnitAttr, and I believe it's essential to allow users the freedom to avoid constraining something they don't want to.

Here's what's still missing:

• The documentation needs to be updated.
• A lot of tests to be written.
• The actual region verification is pending.

To ensure the correctness of the code, I intentionally emitted errors in the RegionConstraint::verify function. The tests produced the expected errors, which is a good sign.

However, I'm currently facing an issue when running ConstraintVerifier on the region arguments. The BlockArgument type is mlir::Value, not mlir::Attribute, so I'm unable to pass it to the verify method. Do you have any suggestions on how to overcome this?

Please, keep in mind that the code is still a work in progress, so I'm open to any further suggestions you might have.

[math-fehr]

Nice! For the mlir::Value, the solution is to wrap the value type in a TypeAttr. This is exactly how operands are handled for instance.

This is a way to handle both attributes and types using the same system, so we reduce a bit the complexity of the dialect!

mlir/include/mlir/Dialect/IRDL/IR/IRDLInterfaces.td

42–48

I guess you don't need the cppNamespace here, and you could add the description to the base class (and probably add an argument to VerifyInterface to make it templated).
Something like let description = "Interface to get an IRDL " # elementName # " constraint verifier from an operation"

[Mogball]

LGTM but please wait for @math-fehr

mlir/include/mlir/Dialect/IRDL/IR/IRDLInterfaces.td

18–19

Please make this line less than 80 characters wide

50

What is the purpose of these interfaces? They have no methods and are only used on 1 op. Is there a plan to introduce more ops that implement these interfaces?

mlir/include/mlir/Dialect/IRDL/IR/IRDLTypes.td

57

no description?

mlir/lib/Dialect/IRDL/IR/IRDLOps.cpp

17

Please add a short doc for this method

mlir/lib/Dialect/IRDL/IRDLLoading.cpp

271

drop trivial braces

[unterumarmung]

mlir/include/mlir/Dialect/IRDL/IR/IRDLInterfaces.td

50

Both VerifyConstraintInterface and VerifyRegionInterface each have a method defined in the base class. While VerifyRegionInterface is currently only used by one operation, VerifyConstraintInterface is used by all constraint operations.

In the initial version of this patch, @math-fehr suggested that RegionConstraint should be treated as its own type of constraint, separate from the primary concepts. This is because it operates on the !irdl.region type rather than the !irdl.attribute type. While working on the patch, my goal was to maintain the close resemblance of the region verification functionality to the original implementation. This approach minimizes confusion and adheres to the interface segregation pattern.

Although it's uncertain whether VerifyRegionInterface will be utilized by multiple operations in the future, I believe it's beneficial to retain it in order to reuse patterns and code between the primary constraint verification and the region verification processes.

mlir/include/mlir/Dialect/IRDL/IR/IRDLTypes.td

57

I'm going to fix it before shipping

[Mogball]

mlir/include/mlir/Dialect/IRDL/IR/IRDLInterfaces.td

50

Makes sense to me.

[unterumarmung]

All implemented and fixed

[unterumarmung]

Stylistic changes

[unterumarmung]

@math-fehr
I have implemented the constraint checking, written tests, updated the documentation, and addressed the review comments.

Please take a look :)

Regarding the naming of the tests file: we already have the attributes-op test that checks for invalid inputs for the operation. So, I followed this naming convention and renamed the file to regions-ops to better align with our existing practice. Currently, there are only two tests in the file. I can update them both to the style of your choice. However, I believe we should not limit ourselves to just "invalid" tests in these files, as we might include "valid" tests in the future for various purposes.

[math-fehr]

Nice!
I added more comment, notably in the implementation of the region verifier. I think there is currently a bug at least!
For the testing files, we can have valid files directly in the regions-ops.irdl.mlir, it's just that if we do, we cannot load them to test their implementation.
This is why I put all valid files in testd.irdl.mlir, and the one failing in a separate file!

mlir/include/mlir/Dialect/IRDL/IR/IRDLOps.td

383–384

Nice!

mlir/include/mlir/Dialect/IRDL/IRDLVerifiers.h

183

Maybe adding a simple documentation for the class?

184

You can inline the constructor here directly. And You don't need explicit here, as you have more than one argument.

188

Can you add documentation for this function?
At least explaining that constraintContext will be used for the region arguments.

193

Can we maybe make this an optional<SmallVector<unsigned>>, and remove the constrainArguments?

mlir/lib/Dialect/IRDL/IR/IRDL.cpp

228–229

Can you drop the trivial braces here?

mlir/lib/Dialect/IRDL/IR/IRDLOps.cpp

18

Nice!

mlir/lib/Dialect/IRDL/IRDLLoading.cpp

260–263

267–268

You can also drop these braces

385

Should we put this in a shared pointer instead of storing this twice (and recomputing this twice as well)?

403–406

This is a bit hacky, but we need to call again irdlOpVerifier here, with the same arguments.
The reason is that when we are verifying the regions here, some constraints might have already been set by the operands/results.
For instance, if we have

%0 = irdl.any
irdl.operands(%0)
%1 = irdl.region(%0)
irdl.regions(%1)

then we have the constraint that the type of the first argument of the region is equal to the first operand.
However, this requires that the operand is verified in the same context as the region.
Here, you are verifying the operand in the normal verifier, and then verifying the region in the region verifier.

I guess one solution would be to check this again in the region verifier. This is slower, yes, but at the same time the alternative
would be to somehow pass a value between the call of the verifier and the region verifier.

Also, maybe a better solution would be to have this directly in verifier. My understanding is that you can verify things
about the number of blocks in a region or the block arguments in verifier, you just cannot verify things about the operations
contained in it. Am I right @Mogball?

mlir/lib/Dialect/IRDL/IRDLVerifiers.cpp

209–210

Is there a reason you are using formatv here and not previously?
I'm asking because I'm usually just using << for formatting, but I'm not sure what is the expected way to do that.
@Mogball, you probably know more about this?

217

This might fail if there are no arguments, right?
So I guess the error should also be printed at the operation level?

mlir/test/Dialect/IRDL/testd.irdl.mlir

140

Can you add a test like this one:

%0 = irdl.any
irdl.operands(%0)
%1 = irdl.region(%0)
irdl.regions(%1)

And then two tests:

my_op(%0) {
  ^bb(%1: i32):
} : (i32) -> ()

and

my_op(%0) {
  ^bb(%1: i64):
} : (i32) -> ()

To check that we are ensuring that the argument and the operand have the same type?
I feel that this will actually not fail in the current implementation (see my comment about`regionVerifier`)

[unterumarmung]

Address review comments and rebase to main

[unterumarmung]

I would like to clarify your position on test filenames. Are you okay with the current naming, or do you think the filename should be changed?

mlir/lib/Dialect/IRDL/IRDLLoading.cpp

385

In the current implementation, using std::shared_ptr is not necessary, but I'd still like to share some thoughts.

Firstly, the reason I avoided using std::shared_ptr here is that I was initially advised against it due to its atomic reference counter overhead. However, upon further consideration, I realize that it is a legitimate use case, and the actual overhead is likely fairly negligible compared to the entire constraints computation process, especially when it's run more than once. So, I'd be willing to refactor it if needed.

Secondly, I did attempt to refactor to the shared pointer, but I encountered numerous obstacles in doing so. The entire API is tightly coupled to the ArrayRef<std::unique_ptr<Constraint>> type, and introducing changes to support shared_ptr would affect not only this patch but also various other parts of the codebase unrelated to it. Therefore, I believe the API should not expose unique_ptr or shared_ptr directly. Instead, I propose having something like ArrayRef<llvm::AnyRef<Constraint>>, where llvm::AnyRef behaves similarly to llvm::ArrayRef, but instead of encapsulating containers, it encapsulates C++ references, raw pointers, and smart pointers. Is there anything like this already available in the wild? I think it would be beneficial to refactor the API this way because we don't actually care about the ownership semantics at the API level. And if we need shared ownership in the future, we can easily add it without having to change the entire IRDL codebase.

403–406

Running the irdlOpVerifier for the second time, aside from the computation complexity, would also necessitate more changes to the code.

Following your suggestion that it might be possible to verify regions alongside operation verification, I investigated further, and it turned out to be a viable approach. All tests produced the expected results. Additionally, this approach eliminates the need for using shared pointers or computing the constraints objects twice. Therefore, I believe it's a better solution that not only improves efficiency but also reduces boilerplate in the code, making it more maintainable.

mlir/lib/Dialect/IRDL/IRDLVerifiers.cpp

209–210

This is solely my personal preference, but I find creating diagnostics with llvm::formatv much more readable than using operator<<.

There's also llvm::format, which has a printf-like syntax, but I don't like it, and it has some known bugs: Link to the bug report.

Another potential advantage of using llvm::formatv is that it makes it easier to migrate to std::format when LLVM or MLIR decide to adopt C++20 in the future. However, since that's not expected to happen in the near future, I don't consider it a strong argument at this moment.

If it truly matters, I have no problem rewriting the code to follow the operator<< style.

In case there is agreement on using llvm::formatv, I can refactor the entire IRDL codebase to adopt it in the follow-up PR.

217

You're absolutely right; I stumbled upon this mistake when testing the solution. Unfortunately, I overlooked writing the necessary code to address it while preparing the patch for review, and I completely forgot about it afterward.

Thank you for catching this issue. I have now fixed it and also created a test to cover it. Additionally, I refactored emitError to eliminate the need for the bool attachFunc = true argument.

mlir/test/Dialect/IRDL/testd.irdl.mlir

140

They pass with the implementation you've reviewed
But now I've rewritten it and the second one does not pass, so I added expected diagnostics to the test

[unterumarmung]

Return missed WalkResult::interrupt() back

[math-fehr]

I'm fine with the current naming!
In any way, we need separate files for the invalid definitions, so we can't really merge them!

@Mogball, just for confirmation, is it fine to verify region block arguments and number of blocks in verifyInvariants, rather than in verifyRegions? I feel this should be equivalent, as this doesn't depend on operations verifying in verifyRegions.
Also, do you know what is preffered between << and llvm::formatv ?

mlir/lib/Dialect/IRDL/IRDLLoading.cpp

385

If we can keep everything in the "normal" verifier, then that's perfect!

mlir/lib/Dialect/IRDL/IRDLVerifiers.cpp

209–210

I personally am fine for both ;) It's just that I don't know what the guidelines are here!
I'll try to ask on the MLIR discord and see what people say.

[unterumarmung]

@Mogball please take a look, thanks

[Mogball]

Thanks for the ping.

@Mogball, just for confirmation, is it fine to verify region block arguments and number of blocks in verifyInvariants, rather than in verifyRegions? I feel this should be equivalent, as this doesn't depend on operations verifying in verifyRegions.

Yes. verifyRegions runs after the operations in the region have been verified, in case the verifier requires some invariant to be met there. If you just need to check the number of blocks or inspect block arguments, check them in verifyInvariants is fine.

Also, do you know what is preffered between << and llvm::formatv ?

<< is typically preferred.

[unterumarmung]

Rebased to main and changed llvm::formatv to operator<<. @math-fehr please take a look :)

[math-fehr]

Sorry for the delay!
This looks good to me!

mlir/test/Dialect/IRDL/testd.mlir

244–304

These two tests do not have any // CHECK, we should maybe add one like // CHECK: func.func @function_name?

[unterumarmung]

Rebase to main

mlir/test/Dialect/IRDL/testd.mlir

244–304

Agree, added

mlir/include/mlir/Dialect/IRDL/IR/IRDLInterfaces.td

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_IRDL_IR_IRDLINTERFACES
 #define MLIR_DIALECT_IRDL_IR_IRDLINTERFACES
 
 include "mlir/IR/OpBase.td"
 
-def VerifyConstraintInterface : OpInterface<"VerifyConstraintInterface"> {
+class VerifyInterface<string name, string return_type>
+      : OpInterface<"Verify" # name # "Interface"> {
   let cppNamespace = "::mlir::irdl";
 
-  let description = [{
-    Interface to get an IRDL constraint verifier from an operation. 
-  }];
+  let description = "Interface to get an IRDL"
+                  # name # "verifier from an operation.";
 
   let methods = [
     InterfaceMethod<
       [{
         Get an instance of a constraint verifier for the associated operation."
         Returns `nullptr` upon failure.
       }],
-      "std::unique_ptr<::mlir::irdl::Constraint>",
+      "std::unique_ptr<::mlir::irdl::" # return_type # ">",
       "getVerifier",
       (ins "::mlir::ArrayRef<Value>":$valueToConstr,
-      "::mlir::DenseMap<::mlir::irdl::TypeOp, std::unique_ptr<::mlir::DynamicTypeDefinition>> const&":$types,
-      "::mlir::DenseMap<::mlir::irdl::AttributeOp, std::unique_ptr<::mlir::DynamicAttrDefinition>> const&":$attrs)
+      [{::mlir::DenseMap<::mlir::irdl::TypeOp,
+        std::unique_ptr<::mlir::DynamicTypeDefinition>> const&}]:$types,
+      [{::mlir::DenseMap<::mlir::irdl::AttributeOp,
+        std::unique_ptr<::mlir::DynamicAttrDefinition>> const&}]:$attrs)
     >
   ];
 }
 
+def VerifyConstraintInterface : VerifyInterface<"Constraint", "Constraint"> {}
+
+def VerifyRegionInterface : VerifyInterface<"Region", "RegionConstraint"> {}
+
 #endif // MLIR_DIALECT_IRDL_IR_IRDLINTERFACES

mlir/include/mlir/Dialect/IRDL/IR/IRDLOps.td

 }
 
 //===----------------------------------------------------------------------===//
 // IRDL Operation definition
 //===----------------------------------------------------------------------===//
 
 def IRDL_OperationOp : IRDL_Op<"operation",
     [HasParent<"DialectOp">, NoTerminator, NoRegionArguments,
-    AtMostOneChildOf<"OperandsOp, ResultsOp, AttributesOp">, Symbol]> {
+    AtMostOneChildOf<"OperandsOp, ResultsOp, AttributesOp, RegionsOp">,
+    Symbol]> {
   let summary = "Define a new operation";
   let description = [{
     `irdl.operation` defines a new operation belonging to the `irdl.dialect`
     parent.
 
     Operations can define constraints on their operands and results with the
     `irdl.results` and `irdl.operands` operations. If these operations are not
     present in the region, the results or operands are expected to be empty.
let arguments = (ins Variadic<IRDL_AttributeType>:$attributeValues,
                         StrArrayAttr:$attributeValueNames);
   let assemblyFormat = [{
     custom<AttributesOp>($attributeValues, $attributeValueNames) attr-dict 
   }];
 
   let hasVerifier = true;
 }
 
+def IRDL_RegionOp : IRDL_Op<"region",
+    [HasParent<"OperationOp">, VerifyRegionInterface,
+    DeclareOpInterfaceMethods<VerifyRegionInterface>]> {
+  let summary = "Define a region of an operation";
+  let description = [{
+    The irdl.region construct defines a set of characteristics
+    that a region of an operation should satify.
+
+    These characteristics include constraints for the entry block arguments
+    of the region and the total number of blocks it contains.
+    The number of blocks must be a non-zero and non-negative integer,
+    and it is optional by default.
+    The set of constraints for the entry block arguments may be optional or
+    empty. If no parentheses are provided, the set is assumed to be optional,
+    and the arguments are not constrained in any way. If parentheses are
+    provided with no arguments, it means that the region must have
+    no entry block arguments
+
+
+    Example:
+
+    ```mlir
+    irdl.dialect @example {
+      irdl.operation @op_with_regions {
+          %r0 = irdl.region
+          %r1 = irdl.region()
+          %v0 = irdl.is i32
+          %v1 = irdl.is i64
+          %r2 = irdl.region(%v0, %v1)
+          %r3 = irdl.region with size 3
+
+          irdl.regions(%r0, %r1, %r2, %r3)
+      }
+    }
+    ```
+
+    The above snippet demonstrates an operation named `@op_with_regions`,
+    which is constrained to have four regions.
+
+    * Region %r0 doesn't have any constraints on the arguments
+      or the number of blocks.
+    * Region `%r1` should have an empty set of arguments.
+    * Region `%r2` should have two arguments of types `i32` and `i64`.
+    * Region `%r3` should contain exactly three blocks.
+  }];
+  let arguments = (ins Variadic<IRDL_AttributeType>:$entryBlockArgs,
+                    OptionalAttr<I32Attr>:$numberOfBlocks,
+                    UnitAttr:$constrainedArguments);
+  let results = (outs IRDL_RegionType:$output);
+
+  let assemblyFormat = [{
+    ``(`(` $entryBlockArgs $constrainedArguments^ `)`)?
+    ``(` ` `with` `size` $numberOfBlocks^)? attr-dict
+  }];
+
+  let hasVerifier = true;
+}
+
+def IRDL_RegionsOp : IRDL_Op<"regions", [HasParent<"OperationOp">]> {
+  let summary = "Define the regions of an operation";
+  let description = [{
+    `irdl.regions` defines the regions of an operation by accepting
+    values produced by `irdl.region` operation as arguments.
+
+    Example:
+
+    ```mlir
+    irdl.dialect @example {
+      irdl.operation @op_with_regions {
+        %r1 = irdl.region with size 3
+        %0 = irdl.any
+        %r2 = irdl.region(%0)
+        irdl.regions(%r1, %r2)
+      }
+    }
+    ```
+
+    In the snippet above the operation is constrained to have two regions.
+    The first region should contain three blocks.
+    The second region should have one region with one argument.
+  }];
+
+  let arguments = (ins Variadic<IRDL_RegionType>:$args);
+  let assemblyFormat = " `(` $args `)` attr-dict ";
+}
+
 //===----------------------------------------------------------------------===//
 // IRDL Constraint operations
 //===----------------------------------------------------------------------===//
 
 class IRDL_ConstraintOp<string mnemonic, list<Trait> traits = []>
     : IRDL_Op<mnemonic, [VerifyConstraintInterface,
         DeclareOpInterfaceMethods<VerifyConstraintInterface>] # traits> {
 }
 
 def IRDL_IsOp : IRDL_ConstraintOp<"is",
     [ParentOneOf<["TypeOp", "AttributeOp", "OperationOp"]>, Pure]> {
   let summary = "Constraints an attribute/type to be a specific attribute instance";
   let description = [{
     `irdl.is` defines a constraint that only accepts a specific instance of a
     type or attribute.
 
     Example:
 
     ```mlir
     irdl.dialect @cmath {
       irdl.type @complex_i32 {
         %0 = irdl.is i32
         irdl.parameters(%0)
       }
     }
     ```
 
     The above program defines a `complex_i32` type inside the dialect `cmath`
     that can only have a `i32` as its parameter.
   }];
 
   let arguments = (ins AnyAttr:$expected);
   let results = (outs IRDL_AttributeType:$output);
   let assemblyFormat = " $expected ` ` attr-dict ";
 }
 
 def IRDL_ParametricOp : IRDL_ConstraintOp<"parametric",
     [ParentOneOf<["TypeOp", "AttributeOp", "OperationOp"]>, Pure]> {
   let summary = "Constraints an attribute/type base and its parameters";
   let description = [{
     `irdl.parametric` defines a constraint that accepts only a single type
     or attribute base. The attribute base is defined by a symbolic reference
     to the corresponding definition. It will additionally constraint the
     parameters of the type/attribute.
 
     Example:
 

mlir/include/mlir/Dialect/IRDL/IR/IRDLTypes.td

let description = [{
     ```
 
     Here, `%0` and `%1` are both of type `!irdl.attribute`. Note that in
     particular, `%1` will be a handle to a `mlir::TypeAttr` wrapping an
     instance of a `cmath.complex` type.
   }];
 }
 
+def IRDL_RegionType : IRDL_Type<"Region", "region"> {
+  let summary = "IRDL handle to a region definition";
+  let description = [{
+    This type represents a region constraint. It is produced by
+    the `irdl.region` operation and consumed by the `irdl.regions` operation.
+    The region can be constrained on the number of arguments
+    and the number of blocks.
+
+    Example:
+    ```mlir
+    irdl.dialect @example {
+      irdl.operation @op_with_regions {
+        %r1 = irdl.region with size 3
+        %0 = irdl.any
+        %r2 = irdl.region(%0)
+        irdl.regions(%r1, %r2)
+      }
+    }
+    ```
+
+    Here we have `%r1` and `%r2`, both of which have the type `!irdl.region`.
+  }];
+}
+
 #endif // MLIR_DIALECT_IRDL_IR_IRDLTYPES

mlir/include/mlir/Dialect/IRDL/IRDLVerifiers.h

 //===- IRDLVerifiers.h - IRDL verifiers --------------------------- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Verifiers for objects declared by IRDL.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_IRDL_IRDLVERIFIERS_H
 #define MLIR_DIALECT_IRDL_IRDLVERIFIERS_H
 
 #include "mlir/IR/Attributes.h"
+#include "mlir/IR/Region.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
 #include <optional>
 
 namespace mlir {
 struct LogicalResult;
 class InFlightDiagnostic;
 class DynamicAttrDefinition;
 class DynamicTypeDefinition;
 } // namespace mlir

 public:
   virtual ~AnyAttributeConstraint() = default;
 
   LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
                        Attribute attr,
                        ConstraintVerifier &context) const override;
 };
 
+/// A constraint checking that a region satisfies `irdl.region` requirements
+struct RegionConstraint {
+  /// The constructor accepts constrained entities from the `irdl.region`
+  /// operation, such as slots of constraints for the region's arguments and the
+  /// block count.
+
+  // Both entities are optional, which means if an entity is not present, then
+  // it is not constrained.
+  RegionConstraint(std::optional<SmallVector<unsigned>> argumentConstraints,
+                   std::optional<size_t> blockCount)
+      : argumentConstraints(std::move(argumentConstraints)),
+        blockCount(blockCount) {}
+
+  /// Check that the `region` satisfies the constraint.
+  ///
+  /// `constraintContext` is needed to verify the region's arguments
+  /// constraints.
+  LogicalResult verify(mlir::Region &region,
+                       ConstraintVerifier &constraintContext);
+
+private:
+  std::optional<SmallVector<unsigned>> argumentConstraints;
+  std::optional<size_t> blockCount;
+};
 } // namespace irdl
 } // namespace mlir
 
 #endif // MLIR_DIALECT_IRDL_IRDLVERIFIERS_H

mlir/lib/Dialect/IRDL/IR/IRDL.cpp

 //===- IRDL.cpp - IRDL 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/IRDL/IR/IRDL.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinAttributes.h"
+#include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/ExtensibleDialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
+#include "mlir/IR/Operation.h"
+#include "mlir/Support/LLVM.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/Casting.h"
 
 using namespace mlir;
 using namespace mlir::irdl;
static void printAttributesOp(OpAsmPrinter &p, AttributesOp op,
   if (attrNames.empty())
     return;
   p << "{";
   interleaveComma(llvm::seq<int>(0, attrNames.size()), p,
                   [&](int i) { p << attrNames[i] << " = " << attrArgs[i]; });
   p << '}';
 }
 
+LogicalResult RegionOp::verify() {
+  if (IntegerAttr numberOfBlocks = getNumberOfBlocksAttr())
+    if (int64_t number = numberOfBlocks.getInt(); number <= 0) {
+      return emitOpError("the number of blocks is expected to be >= 1 but got ")
+             << number;
+    }
+  return success();
+}
+
 #include "mlir/Dialect/IRDL/IR/IRDLInterfaces.cpp.inc"
 
 #define GET_TYPEDEF_CLASSES
 #include "mlir/Dialect/IRDL/IR/IRDLTypesGen.cpp.inc"
 
 #include "mlir/Dialect/IRDL/IR/IRDLEnums.cpp.inc"
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/IRDL/IR/IRDLAttributes.cpp.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/IRDL/IR/IRDLOps.cpp.inc"

mlir/lib/Dialect/IRDL/IR/IRDLOps.cpp

 //===- IRDLOps.cpp - IRDL 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/IRDL/IR/IRDL.h"
+#include "mlir/IR/ValueRange.h"
+#include <optional>
 
 using namespace mlir;
 using namespace mlir::irdl;
 
+/// Maps given `args` to the index in the `valueToConstr`
+static SmallVector<unsigned>
+getConstraintIndicesForArgs(mlir::OperandRange args,
+                            ArrayRef<Value> valueToConstr) {
+  SmallVector<unsigned> constraints;
+  for (Value arg : args) {
+    for (auto [i, value] : enumerate(valueToConstr)) {
+      if (value == arg) {
+        constraints.push_back(i);
+        break;
+      }
+    }
+  }
+  return constraints;
+}
+
 std::unique_ptr<Constraint> IsOp::getVerifier(
     ArrayRef<Value> valueToConstr,
     DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> const &types,
     DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> const
         &attrs) {
   return std::make_unique<IsConstraint>(getExpectedAttr());
 }
 
 std::unique_ptr<Constraint> ParametricOp::getVerifier(
     ArrayRef<Value> valueToConstr,
     DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> const &types,
     DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> const
         &attrs) {
-  SmallVector<unsigned> constraints;
-  for (Value arg : getArgs()) {
-    for (auto [i, value] : enumerate(valueToConstr)) {
-      if (value == arg) {
-        constraints.push_back(i);
-        break;
-      }
-    }
-  }
+  SmallVector<unsigned> constraints =
+      getConstraintIndicesForArgs(getArgs(), valueToConstr);
 
   // Symbol reference case for the base
   SymbolRefAttr symRef = getBaseType();
   Operation *defOp =
       SymbolTable::lookupNearestSymbolFrom(getOperation(), symRef);
   if (!defOp) {
     emitError() << symRef << " does not refer to any existing symbol";
     return nullptr;
llvm_unreachable("verifier should ensure that the referenced operation is "
                    "either a type or an attribute definition");
 }
 
 std::unique_ptr<Constraint> AnyOfOp::getVerifier(
     ArrayRef<Value> valueToConstr,
     DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> const &types,
     DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> const
         &attrs) {
-  SmallVector<unsigned> constraints;
-  for (Value arg : getArgs()) {
-    for (auto [i, value] : enumerate(valueToConstr)) {
-      if (value == arg) {
-        constraints.push_back(i);
-        break;
-      }
-    }
-  }
-
-  return std::make_unique<AnyOfConstraint>(constraints);
+  return std::make_unique<AnyOfConstraint>(
+      getConstraintIndicesForArgs(getArgs(), valueToConstr));
 }
 
 std::unique_ptr<Constraint> AllOfOp::getVerifier(
     ArrayRef<Value> valueToConstr,
     DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> const &types,
     DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> const
         &attrs) {
-  SmallVector<unsigned> constraints;
-  for (Value arg : getArgs()) {
-    for (auto [i, value] : enumerate(valueToConstr)) {
-      if (value == arg) {
-        constraints.push_back(i);
-        break;
-      }
-    }
-  }
-
-  return std::make_unique<AllOfConstraint>(constraints);
+  return std::make_unique<AllOfConstraint>(
+      getConstraintIndicesForArgs(getArgs(), valueToConstr));
 }
 
 std::unique_ptr<Constraint> AnyOp::getVerifier(
     ArrayRef<Value> valueToConstr,
     DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> const &types,
     DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> const
         &attrs) {
   return std::make_unique<AnyAttributeConstraint>();
 }
+
+std::unique_ptr<RegionConstraint> RegionOp::getVerifier(
+    ArrayRef<Value> valueToConstr,
+    DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> const &types,
+    DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> const
+        &attrs) {
+  return std::make_unique<RegionConstraint>(
+      getConstrainedArguments() ? std::optional{getConstraintIndicesForArgs(
+                                      getEntryBlockArgs(), valueToConstr)}
+                                : std::nullopt,
+      getNumberOfBlocks());
+}

mlir/lib/Dialect/IRDL/IRDLLoading.cpp

 //===- IRDLLoading.cpp - IRDL dialect loading --------------------- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Manages the loading of MLIR objects from IRDL operations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/IRDL/IRDLLoading.h"
 #include "mlir/Dialect/IRDL/IR/IRDL.h"
 #include "mlir/Dialect/IRDL/IR/IRDLInterfaces.h"
+#include "mlir/Dialect/IRDL/IRDLVerifiers.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/ExtensibleDialect.h"
 #include "mlir/IR/OperationSupport.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/SMLoc.h"
LogicalResult getResultSegmentSizes(Operation *op,
   return getSegmentSizes(op, "result", "result_segment_sizes",
                          op->getNumResults(), variadicities, segmentSizes);
 }
 
 /// Verify that the given operation satisfies the given constraints.
 /// This encodes the logic of the verification method for operations defined
 /// with IRDL.
 static LogicalResult irdlOpVerifier(
-    Operation *op, ArrayRef<std::unique_ptr<Constraint>> constraints,
+    Operation *op, ConstraintVerifier &verifier,
     ArrayRef<size_t> operandConstrs, ArrayRef<Variadicity> operandVariadicity,
     ArrayRef<size_t> resultConstrs, ArrayRef<Variadicity> resultVariadicity,
     const DenseMap<StringAttr, size_t> &attributeConstrs) {
   // Get the segment sizes for the operands.
   // This will check that the number of operands is correct.
   SmallVector<int> operandSegmentSizes;
   if (failed(
           getOperandSegmentSizes(op, operandVariadicity, operandSegmentSizes)))
     return failure();
 
   // Get the segment sizes for the results.
   // This will check that the number of results is correct.
   SmallVector<int> resultSegmentSizes;
   if (failed(getResultSegmentSizes(op, resultVariadicity, resultSegmentSizes)))
     return failure();
 
   auto emitError = [op] { return op->emitError(); };
 
-  ConstraintVerifier verifier(constraints);
-
   /// Сheck that we have all needed attributes passed
   /// and they satisfy the constraints.
   DictionaryAttr actualAttrs = op->getAttrDictionary();
 
   for (auto [name, constraint] : attributeConstrs) {
     /// First, check if the attribute actually passed.
     std::optional<NamedAttribute> actual = actualAttrs.getNamed(name);
     if (!actual.has_value())
for (int i = 0; i < segmentSize; i++) {
         return failure();
       ++resultIdx;
     }
   }
 
   return success();
 }
 
+static LogicalResult irdlRegionVerifier(
+    Operation *op, ConstraintVerifier &verifier,
+    ArrayRef<std::unique_ptr<RegionConstraint>> regionsConstraints) {
+  if (op->getNumRegions() != regionsConstraints.size()) {
+    return op->emitOpError()
+           << "unexpected number of regions: expected "
+           << regionsConstraints.size() << " but got " << op->getNumRegions();
+  }
+
+  for (auto [constraint, region] :
+       llvm::zip(regionsConstraints, op->getRegions()))
+    if (failed(constraint->verify(region, verifier)))
+      return failure();
+
+  return success();
+}
+
 /// Define and load an operation represented by a `irdl.operation`
 /// operation.
 static WalkResult loadOperation(
     OperationOp op, ExtensibleDialect *dialect,
     DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> &types,
     DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> &attrs) {
   // Resolve SSA values to verifier constraint slots
   SmallVector<Value> constrToValue;
+  SmallVector<Value> regionToValue;
   for (Operation &op : op->getRegion(0).getOps()) {
     if (isa<VerifyConstraintInterface>(op)) {
       if (op.getNumResults() != 1)
         return op.emitError()
                << "IRDL constraint operations must have exactly one result";
       constrToValue.push_back(op.getResult(0));
     }
+    if (isa<VerifyRegionInterface>(op)) {
+      if (op.getNumResults() != 1)
+        return op.emitError()
+               << "IRDL constraint operations must have exactly one result";
+      regionToValue.push_back(op.getResult(0));
+    }
   }
 
   // Build the verifiers for each constraint slot
   SmallVector<std::unique_ptr<Constraint>> constraints;
   for (Value v : constrToValue) {
     VerifyConstraintInterface op =
         cast<VerifyConstraintInterface>(v.getDefiningOp());
     std::unique_ptr<Constraint> verifier =
         op.getVerifier(constrToValue, types, attrs);
     if (!verifier)
       return WalkResult::interrupt();
     constraints.push_back(std::move(verifier));
   }
 
+  // Build region constraints
+  SmallVector<std::unique_ptr<RegionConstraint>> regionConstraints;
+  for (Value v : regionToValue) {
+    VerifyRegionInterface op = cast<VerifyRegionInterface>(v.getDefiningOp());
+    std::unique_ptr<RegionConstraint> verifier =
+        op.getVerifier(constrToValue, types, attrs);
+    regionConstraints.push_back(std::move(verifier));
+  }
+
   SmallVector<size_t> operandConstraints;
   SmallVector<Variadicity> operandVariadicity;
 
   // Gather which constraint slots correspond to operand constraints
   auto operandsOp = op.getOp<OperandsOp>();
   if (operandsOp.has_value()) {
     operandConstraints.reserve(operandsOp->getArgs().size());
     for (Value operand : operandsOp->getArgs()) {
static WalkResult loadOperation(
   // IRDL does not support defining custom parsers or printers.
   auto parser = [](OpAsmParser &parser, OperationState &result) {
     return failure();
   };
   auto printer = [](Operation *op, OpAsmPrinter &printer, StringRef) {
     printer.printGenericOp(op);
   };
 
   auto verifier =
       [constraints{std::move(constraints)},
+       regionConstraints{std::move(regionConstraints)},
        operandConstraints{std::move(operandConstraints)},
        operandVariadicity{std::move(operandVariadicity)},
        resultConstraints{std::move(resultConstraints)},
        resultVariadicity{std::move(resultVariadicity)},
        attributesContraints{std::move(attributesContraints)}](Operation *op) {
-        return irdlOpVerifier(op, constraints, operandConstraints,
-                              operandVariadicity, resultConstraints,
-                              resultVariadicity, attributesContraints);
+        ConstraintVerifier verifier(constraints);
+        const LogicalResult opVerifierResult = irdlOpVerifier(
+            op, verifier, operandConstraints, operandVariadicity,
+            resultConstraints, resultVariadicity, attributesContraints);
+        const LogicalResult opRegionVerifierResult =
+            irdlRegionVerifier(op, verifier, regionConstraints);
+        return LogicalResult::success(opVerifierResult.succeeded() &&
+                                      opRegionVerifierResult.succeeded());
       };
 
-  // IRDL does not support defining regions.
-  auto regionVerifier = [](Operation *op) { return success(); };
+  // IRDL supports only checking number of blocks and argument contraints
+  // It is done in the main verifier to reuse `ConstraintVerifier` context
+  auto regionVerifier = [](Operation *op) { return LogicalResult::success(); };
 
   auto opDef = DynamicOpDefinition::get(
       op.getName(), dialect, std::move(verifier), std::move(regionVerifier),
       std::move(parser), std::move(printer));
   dialect->registerDynamicOp(std::move(opDef));
 
   return WalkResult::advance();
 }
 

mlir/lib/Dialect/IRDL/IRDLVerifiers.cpp

 //===- IRDLVerifiers.cpp - IRDL verifiers ------------------------- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Verifiers for objects declared by IRDL.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/IRDL/IRDLVerifiers.h"
+#include "mlir/IR/Attributes.h"
+#include "mlir/IR/Block.h"
+#include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/ExtensibleDialect.h"
+#include "mlir/IR/Location.h"
+#include "mlir/IR/Region.h"
+#include "mlir/IR/Value.h"
 #include "mlir/Support/LogicalResult.h"
+#include "llvm/Support/FormatVariadic.h"
 
 using namespace mlir;
 using namespace mlir::irdl;
 
 ConstraintVerifier::ConstraintVerifier(
     ArrayRef<std::unique_ptr<Constraint>> constraints)
     : constraints(constraints), assigned() {
   assigned.resize(this->constraints.size());

 }
 
 LogicalResult
 AnyAttributeConstraint::verify(function_ref<InFlightDiagnostic()> emitError,
                                Attribute attr,
                                ConstraintVerifier &context) const {
   return success();
 }
+
+LogicalResult RegionConstraint::verify(mlir::Region &region,
+                                       ConstraintVerifier &constraintContext) {
+  const auto emitError = [parentOp = region.getParentOp()](mlir::Location loc) {
+    return [loc, parentOp] {
+      InFlightDiagnostic diag = mlir::emitError(loc);
+      // If we already have been given location of the parent operation, which
+      // might happen when the region location is passed, we do not want to
+      // produce the note on the same location
+      if (loc != parentOp->getLoc())
+        diag.attachNote(parentOp->getLoc()).append("see the operation");
+      return diag;
+    };
+  };
+
+  if (blockCount.has_value() && *blockCount != region.getBlocks().size()) {
+    return emitError(region.getLoc())()
+           << "expected region " << region.getRegionNumber() << " to have "
+           << *blockCount << " block(s) but got " << region.getBlocks().size();
+  }
+
+  if (argumentConstraints.has_value()) {
+    auto actualArgs = region.getArguments();
+    if (actualArgs.size() != argumentConstraints->size()) {
+      const mlir::Location firstArgLoc =
+          actualArgs.empty() ? region.getLoc() : actualArgs.front().getLoc();
+      return emitError(firstArgLoc)()
+             << "expected region " << region.getRegionNumber() << " to have "
+             << argumentConstraints->size() << " arguments but got "
+             << actualArgs.size();
+    }
+
+    for (auto [arg, constraint] : llvm::zip(actualArgs, *argumentConstraints)) {
+      mlir::Attribute type = TypeAttr::get(arg.getType());
+      if (failed(constraintContext.verify(emitError(arg.getLoc()), type,
+                                          constraint))) {
+        return failure();
+      }
+    }
+  }
+  return success();
+}

mlir/test/Dialect/IRDL/regions-ops.irdl.mlir

+// RUN: mlir-opt %s -verify-diagnostics -split-input-file
+
+irdl.dialect @testRegionOpNegativeNumber {
+    irdl.operation @op {
+        // expected-error @below {{'irdl.region' op the number of blocks is expected to be >= 1 but got -42}}
+        %r1 = irdl.region with size -42
+    }
+}
+
+// -----
+
+irdl.dialect @testRegionsOpWrongOperation {
+    irdl.operation @op {
+        // expected-note @below {{prior use here}}
+        %r1 = irdl.any
+        // expected-error @below {{use of value '%r1' expects different type than prior uses: '!irdl.region' vs '!irdl.attribute'}}
+        irdl.regions(%r1)
+    }
+}

mlir/test/Dialect/IRDL/testd.irdl.mlir

irdl.operation @attrs {
     %0 = irdl.is i32
     %1 = irdl.is i64
 
     irdl.attributes {
       "attr1" = %0,
       "attr2" = %1
     }
   }
+  // CHECK: irdl.operation @regions {
+  // CHECK:   %[[r0:[^ ]*]] = irdl.region
+  // CHECK:   %[[v0:[^ ]*]] = irdl.is i32
+  // CHECK:   %[[v1:[^ ]*]] = irdl.is i64
+  // CHECK:   %[[r1:[^ ]*]] = irdl.region(%[[v0]], %[[v1]])
+  // CHECK:   %[[r2:[^ ]*]] = irdl.region with size 3
+  // CHECK:   %[[r3:[^ ]*]] = irdl.region()
+  // CHECK:   irdl.regions(%[[r0]], %[[r1]], %[[r2]], %[[r3]])
+  // CHECK: }
+  irdl.operation @regions {
+    %r0 = irdl.region
+    %v0 = irdl.is i32
+    %v1 = irdl.is i64
+    %r1 = irdl.region(%v0, %v1)
+    %r2 = irdl.region with size 3
+    %r3 = irdl.region()
+
+    irdl.regions(%r0, %r1, %r2, %r3)
+  }
+
+  // CHECK: irdl.operation @region_and_operand {
+  // CHECK:   %[[v0:[^ ]*]] = irdl.any
+  // CHECK:   %[[r0:[^ ]*]] = irdl.region(%[[v0]])
+  // CHECK:   irdl.operands(%[[v0]])
+  // CHECK:   irdl.regions(%[[r0]])
+  // CHECK: }
+  irdl.operation @region_and_operand {
+    %v0 = irdl.any
+    %r0 = irdl.region(%v0)
+
+    irdl.operands(%v0)
+    irdl.regions(%r0)
+  }
 }

mlir/test/Dialect/IRDL/testd.mlir

 
 // -----
 
 func.func @failedAttrsConstraint2() {
   // expected-error@+1 {{expected 'i64' but got 'i32'}}
   "testd.attrs"() {attr1 = i32, attr2 = i32} : () -> ()
   return
 }
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// Regions
+//===----------------------------------------------------------------------===//
+
+// CHECK: func.func @succeededRegions
+func.func @succeededRegions() {
+  "testd.regions"() (
+  {
+    ^bb1:
+      llvm.unreachable
+  },
+  {
+    ^bb1(%arg0: i32, %arg1: i64):
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      cf.br ^bb3
+    ^bb2:
+      cf.br ^bb3
+    ^bb3:
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      llvm.unreachable
+  }) : () -> ()
+
+  return
+}
+// -----
+
+// CHECK: func.func @succeededRegionWithNoConstraints
+func.func @succeededRegionWithNoConstraints() {
+  "testd.regions"() (
+  {
+    ^bb1(%arg0: i32, %arg1: i64, %arg2 : f64):
+      llvm.unreachable
+    ^bb2(%arg3: i32, %arg4: i64, %arg5 : f64):
+      llvm.unreachable
+    ^bb3(%arg6: i32, %arg7: i64, %arg8 : f64):
+      llvm.unreachable
+    ^bb4(%arg9: i32, %arg10: i64, %arg11 : f64):
+      llvm.unreachable
+    ^bb5(%arg12: i32, %arg13: i64, %arg14 : f64):
+      llvm.unreachable
+  },
+  {
+    ^bb1(%arg0: i32, %arg1: i64):
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      cf.br ^bb3
+    ^bb2:
+      cf.br ^bb3
+    ^bb3:
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      llvm.unreachable
+  }) : () -> ()
+
+  return
+}
+
+// -----
+
+func.func @failedRegionArgsLessThanNeeded() {
+  // expected-note@+1 {{see the operation}}
+  "testd.regions"() (
+  {
+    ^bb1:
+      llvm.unreachable
+  },
+  {
+    // expected-error@+1 {{expected region 1 to have 2 arguments but got 1}}
+    ^bb1(%arg0: i32):
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      cf.br ^bb3
+    ^bb2:
+      cf.br ^bb3
+    ^bb3:
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      llvm.unreachable
+  }) : () -> ()
+
+  return
+}
+
+// -----
+
+func.func @failedRegionArgsMoreThanNeeded() {
+  // expected-note@+1 {{see the operation}}
+  "testd.regions"() (
+  {
+    ^bb1:
+      llvm.unreachable
+  },
+  {
+    // expected-error@+1 {{expected region 1 to have 2 arguments but got 3}}
+    ^bb1(%arg0: i32, %arg1: i64, %arg2 : f64):
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      cf.br ^bb3
+    ^bb2:
+      cf.br ^bb3
+    ^bb3:
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      llvm.unreachable
+  }) : () -> ()
+
+  return
+}
+
+// -----
+
+func.func @failedRegionArgsEmptyButRequired() {
+  // expected-error@+1 {{expected region 1 to have 2 arguments but got 0}}
+  "testd.regions"() (
+  {
+    ^bb1:
+      llvm.unreachable
+  },
+  {
+    ^bb1():
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      cf.br ^bb3
+    ^bb2:
+      cf.br ^bb3
+    ^bb3:
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      llvm.unreachable
+  }) : () -> ()
+
+  return
+}
+
+// -----
+
+func.func @faIledRegionArgsConstraint() {
+  // expected-note@+1 {{see the operation}}
+  "testd.regions"() (
+  {
+    ^bb1:
+      llvm.unreachable
+  },
+  {
+    // expected-error@+1 {{expected 'i64' but got 'f64'}}
+    ^bb1(%arg0: i32, %arg1: f64):
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      cf.br ^bb3
+    ^bb2:
+      cf.br ^bb3
+    ^bb3:
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      llvm.unreachable
+  }) : () -> ()
+
+  return
+}
+
+// -----
+
+func.func @failedRegionBlocksCountLessThanNeeded() {
+  // expected-error@+1 {{expected region 2 to have 3 block(s) but got 2}}
+  "testd.regions"() (
+  {
+    ^bb1:
+      llvm.unreachable
+  },
+  {
+    ^bb1(%arg0: i32, %arg1: i64):
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      cf.br ^bb3
+    ^bb3:
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      llvm.unreachable
+  }) : () -> ()
+
+  return
+}
+
+// -----
+
+func.func @failedRegionBlocksCountMoreThanNeeded() {
+  // expected-error@+1 {{expected region 2 to have 3 block(s) but got 4}}
+  "testd.regions"() (
+  {
+    ^bb1:
+      llvm.unreachable
+  },
+  {
+    ^bb1(%arg0: i32, %arg1: i64):
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      cf.br ^bb3
+    ^bb2:
+      cf.br ^bb3
+    ^bb4:
+      cf.br ^bb3
+    ^bb3:
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      llvm.unreachable
+  }) : () -> ()
+
+  return
+}
+
+// -----
+
+func.func @failedRegionWithEmptyArgs() {
+  // expected-note@+1 {{see the operation}}
+  "testd.regions"() (
+  {
+    ^bb1:
+      llvm.unreachable
+  },
+  {
+    ^bb1(%arg0: i32, %arg1: i64):
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      cf.br ^bb3
+    ^bb2:
+      cf.br ^bb3
+    ^bb3:
+      llvm.unreachable
+  },
+  {
+    // expected-error@+1 {{expected region 3 to have 0 arguments but got 2}}
+    ^bb1(%arg0: i32, %arg1: i64):
+      llvm.unreachable
+  }) : () -> ()
+
+  return
+}
+
+// -----
+
+func.func @failedRegionWithLessBlocksThanNeeded() {
+  // expected-error@+1 {{'testd.regions' op unexpected number of regions: expected 4 but got 3}}
+  "testd.regions"() (
+  {
+    ^bb1:
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      cf.br ^bb3
+    ^bb2:
+      cf.br ^bb3
+    ^bb3:
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      llvm.unreachable
+  }) : () -> ()
+
+  return
+}
+
+// -----
+
+func.func @failedRegionWithMoreBlocksThanNeeded() {
+  // expected-error@+1 {{'testd.regions' op unexpected number of regions: expected 4 but got 5}}
+  "testd.regions"() (
+  {
+    ^bb1:
+      llvm.unreachable
+  },
+  {
+    ^bb1(%arg0: i32, %arg1: i64):
+      llvm.unreachable
+  },
+  {
+    ^bb1:
+      cf.br ^bb3
+    ^bb2:
+      cf.br ^bb3
+    ^bb3:
+      llvm.unreachable
+  },
+  {
+    ^bb1(%arg0: i32, %arg1: i64):
+      llvm.unreachable
+  },
+  {
+    ^bb1(%arg0: i32, %arg1: i64):
+      llvm.unreachable
+  }) : () -> ()
+
+  return
+}
+
+// -----
+
+func.func @successReuseConstraintBetweenRegionAndOperand() {
+  %0 = arith.constant 42 : i32
+  "testd.region_and_operand"(%0) ({
+    ^bb(%1: i32):
+      llvm.unreachable
+  }) : (i32) -> ()
+
+  return
+}
+
+// -----
+
+func.func @failedReuseConstraintBetweenRegionAndOperand() {
+  %0 = arith.constant 42 : i32
+  // expected-note@+1 {{see the operation}}
+  "testd.region_and_operand"(%0) ({
+    // expected-error@+1 {{expected 'i32' but got 'i64'}}
+    ^bb(%1: i64):
+      llvm.unreachable
+  }) : (i32) -> ()
+
+  return
+}