[mlir][irdl] Add `irdl.any_of` operation

[math-fehr]

Summary

The irdl.any_of operation represent a constraint that is satisfied
if any of its subconstraint is satisfied.

For instance, in the following example:

%0 = irdl.is f32
%1 = irdl.is f64
%2 = irdl.any_of(f32, f64)

%2 can only be satisfied by f32 or f64.

Note that the verification algorithm required by irdl.any_of is
non-trivial, since we want that the order of arguments of
irdl.any_of to not matter. For this reason, our registration
algorithm fails if two constraints used by any_of might be
satisfied by the same Attribute. This is approximated by checking
the possible Attribute bases of each constraints.

Depends on D145734

[Mogball]

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

59

61

can these be const?

mlir/lib/Dialect/IRDL/IRDLRegistration.cpp

419 ↗

(On Diff #503959)

[math-fehr]

Address comments, and rebase on main

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

def VerifyConstraintInterface : OpInterface<"VerifyConstraintInterface"> {
   let methods = [
     InterfaceMethod<
       [{
         Get an instance of a constraint verifier for the associated operation."
         Returns `nullptr` upon failure.
       }],
       "std::unique_ptr<::mlir::irdl::Constraint>",
       "getVerifier",
-      (ins "::mlir::SmallVector<Value> const&":$valueRes,
-      "::mlir::DenseMap<::mlir::irdl::TypeOp, std::unique_ptr<::mlir::DynamicTypeDefinition>> &":$types,
-      "::mlir::DenseMap<::mlir::irdl::AttributeOp, std::unique_ptr<::mlir::DynamicAttrDefinition>> &":$attrs)
+      (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)
     >
   ];
 }
 
 #endif // MLIR_DIALECT_IRDL_IR_IRDLINTERFACES

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

let description = [{
     The above program defines a type `complex_flexible` inside the dialect
     `cmath` that has a single parameter that can be any attribute.
   }];
 
   let results = (outs IRDL_AttributeType:$output);
   let assemblyFormat = " attr-dict ";
 }
 
+def IRDL_AnyOf : IRDL_ConstraintOp<"any_of",
+                  [ParentOneOf<["TypeOp", "AttributeOp", "OperationOp"]>,
+                   SameOperandsAndResultType]> {
+  let summary = "Constraints to the union of the provided constraints";
+  let description = [{
+    `irdl.any_of` defines a constraint that accepts any type or attribute that
+    satisfies at least one of its provided type constraints.
+
+    Example:
+
+    ```mlir
+    irdl.dialect cmath {
+      irdl.type complex {
+        %0 = irdl.is i32
+        %1 = irdl.is i64
+        %2 = irdl.is f32
+        %3 = irdl.is f64
+        %4 = irdl.any_of(%0, %1, %2, %3)
+        irdl.parameters(%4)
+      }
+    }
+    ```
+
+    The above program defines a type `complex` inside the dialect `cmath` that
+    can have a single type parameter that can be either `i32`, `i64`, `f32` or
+    `f32`.
+  }];
+
+  let arguments = (ins Variadic<IRDL_AttributeType>:$args);
+  let results = (outs IRDL_AttributeType:$output);
+  let assemblyFormat = [{ `(` $args `)` ` ` attr-dict }];
+}
+
+def IRDL_AllOf : IRDL_ConstraintOp<"all_of",
+                 [ParentOneOf<["TypeOp", "AttributeOp", "OperationOp"]>,
+                  SameOperandsAndResultType]> {
+  let summary = "Constraints to the intersection of the provided constraints";
+  let description = [{
+    `irdl.all_of` defines a constraint that accepts any type or attribute that
+    satisfies all of its provided constraints.
+
+    Example:
+
+    ```mlir
+    irdl.dialect cmath {
+      irdl.type complex_f32 {
+        %0 = irdl.is i32
+        %1 = irdl.is f32
+        %2 = irdl.any_of(%0, %1) // is 32-bit
+
+        %3 = irdl.is f32
+        %4 = irdl.is f64
+        %5 = irdl.any_of(%3, %4) // is a float
+
+        %6 = irdl.all_of(%2, %5) // is a 32-bit float
+        irdl.parameters(%6)
+      }
+    }
+    ```
+
+    The above program defines a type `complex` inside the dialect `cmath` that
+    can has one parameter that must be 32-bit long and a float (in other
+    words, that must be `f32`).
+  }];
+
+  let arguments = (ins Variadic<IRDL_AttributeType>:$args);
+  let results = (outs IRDL_AttributeType:$output);
+  let assemblyFormat = [{ `(` $args `)` ` ` attr-dict }];
+}
 
 #endif // MLIR_DIALECT_IRDL_IR_IRDLOPS

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"
 
 using namespace mlir;
 using namespace mlir::irdl;
 
 std::unique_ptr<Constraint> Is::getVerifier(
-    SmallVector<Value> const &valueToConstr,
-    DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> &types,
-    DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> &attrs) {
+    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> Parametric::getVerifier(
-    SmallVector<Value> const &valueToConstr,
-    DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> &types,
-    DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> &attrs) {
+    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;
       }
     }
   }
 
   // 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;
   }
 
   if (auto typeOp = dyn_cast<TypeOp>(defOp))
-    return std::make_unique<DynParametricTypeConstraint>(types[typeOp].get(),
+    return std::make_unique<DynParametricTypeConstraint>(types.at(typeOp).get(),
                                                          constraints);
 
   if (auto attrOp = dyn_cast<AttributeOp>(defOp))
-    return std::make_unique<DynParametricAttrConstraint>(attrs[attrOp].get(),
+    return std::make_unique<DynParametricAttrConstraint>(attrs.at(attrOp).get(),
                                                          constraints);
 
   llvm_unreachable("verifier should ensure that the referenced operation is "
                    "either a type or an attribute definition");
 }
 
+std::unique_ptr<Constraint> AnyOf::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);
+}
+
+std::unique_ptr<Constraint> AllOf::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);
+}
+
 std::unique_ptr<Constraint> Any::getVerifier(
-    SmallVector<Value> const &valueToConstr,
-    DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> &types,
-    DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> &attrs) {
+    ArrayRef<Value> valueToConstr,
+    DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> const &types,
+    DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> const
+        &attrs) {
   return std::make_unique<AnyAttributeConstraint>();
 }

mlir/lib/Dialect/IRDL/IRDLLoading.cpp

return irdlAttrOrTypeVerifier(emitError, params, constraints,
                                   paramConstraints);
   };
 
   // While the `std::move` is not required, not adding it triggers a bug in
   // clang-10.
   return std::move(verifier);
 }
 
+/// Get the possible bases of a constraint. Return `true` if all bases can
+/// potentially be matched.
+/// A base is a type or an attribute definition. For instance, the base of
+/// `irdl.parametric "!builtin.complex"(...)` is `builtin.complex`.
+/// This function returns the following information through arguments:
+/// - `paramIds`: the set of type or attribute IDs that are used as bases.
+/// - `paramIrdlOps`: the set of IRDL operations that are used as bases.
+/// - `isIds`: the set of type or attribute IDs that are used in `irdl.is`
+///   constraints.
+static bool getBases(Operation *op, SmallPtrSet<TypeID, 4> &paramIds,
+                     SmallPtrSet<Operation *, 4> &paramIrdlOps,
+                     SmallPtrSet<TypeID, 4> &isIds) {
+  // For `irdl.any_of`, we get the bases from all its arguments.
+  if (auto anyOf = dyn_cast<AnyOf>(op)) {
+    bool has_any = false;
+    for (Value arg : anyOf.getArgs())
+      has_any &= getBases(arg.getDefiningOp(), paramIds, paramIrdlOps, isIds);
+    return has_any;
+  }
+
+  // For `irdl.all_of`, we get the bases from the first argument.
+  // This is restrictive, but we can relax it later if needed.
+  if (auto allOf = dyn_cast<AllOf>(op))
+    return getBases(allOf.getArgs()[0].getDefiningOp(), paramIds, paramIrdlOps,
+                    isIds);
+
+  // For `irdl.parametric`, we get directly the base from the operation.
+  if (auto params = dyn_cast<Parametric>(op)) {
+    SymbolRefAttr symRef = params.getBaseType();
+    Operation *defOp = SymbolTable::lookupNearestSymbolFrom(op, symRef);
+    assert(defOp && "symbol reference should refer to an existing operation");
+    paramIrdlOps.insert(defOp);
+    return false;
+  }
+
+  // For `irdl.is`, we get the base TypeID directly.
+  if (auto is = dyn_cast<Is>(op)) {
+    Attribute expected = is.getExpected();
+    isIds.insert(expected.getTypeID());
+    return false;
+  }
+
+  // For `irdl.any`, we return `false` since we can match any type or attribute
+  // base.
+  if (auto isA = dyn_cast<Any>(op))
+    return true;
+
+  llvm_unreachable("unknown IRDL constraint");
+}
+
+/// Check that an any_of is in the subset IRDL can handle.
+/// IRDL uses a greedy algorithm to match constraints. This means that if we
+/// encounter an `any_of` with multiple constraints, we will match the first
+/// constraint that is satisfied. Thus, the order of constraints matter in
+/// `any_of` with our current algorithm.
+/// In order to make the order of constraints irrelevant, we require that
+/// all `any_of` constraint parameters are disjoint. For this, we check that
+/// the base parameters are all disjoints between `parametric` operations, and
+/// that they are disjoint between `parametric` and `is` operations.
+/// This restriction will be relaxed in the future, when we will change our
+/// algorithm to be non-greedy.
+static LogicalResult checkCorrectAnyOf(AnyOf anyOf) {
+  SmallPtrSet<TypeID, 4> paramIds;
+  SmallPtrSet<Operation *, 4> paramIrdlOps;
+  SmallPtrSet<TypeID, 4> isIds;
+
+  for (Value arg : anyOf.getArgs()) {
+    Operation *argOp = arg.getDefiningOp();
+    SmallPtrSet<TypeID, 4> argParamIds;
+    SmallPtrSet<Operation *, 4> argParamIrdlOps;
+    SmallPtrSet<TypeID, 4> argIsIds;
+
+    // Get the bases of this argument. If it can match any type or attribute,
+    // then our `any_of` should not be allowed.
+    if (getBases(argOp, argParamIds, argParamIrdlOps, argIsIds))
+      return failure();
+
+    // We check that the base parameters are all disjoints between `parametric`
+    // operations, and that they are disjoint between `parametric` and `is`
+    // operations.
+    for (TypeID id : argParamIds) {
+      if (isIds.count(id))
+        return failure();
+      bool inserted = paramIds.insert(id).second;
+      if (!inserted)
+        return failure();
+    }
+
+    // We check that the base parameters are all disjoints with `irdl.is`
+    // operations.
+    for (TypeID id : isIds) {
+      if (paramIds.count(id))
+        return failure();
+      isIds.insert(id);
+    }
+
+    // We check that all `parametric` operations are disjoint. We do not
+    // need to check that they are disjoint with `is` operations, since
+    // `is` operations cannot refer to attributes defined with `irdl.parametric`
+    // operations.
+    for (Operation *op : argParamIrdlOps) {
+      bool inserted = paramIrdlOps.insert(op).second;
+      if (!inserted)
+        return failure();
+    }
+  }
+
+  return success();
+}
+
 /// Load all dialects in the given module, without loading any operation, type
 /// or attribute definitions.
 static DenseMap<DialectOp, ExtensibleDialect *> loadEmptyDialects(ModuleOp op) {
   DenseMap<DialectOp, ExtensibleDialect *> dialects;
   op.walk([&](DialectOp dialectOp) {
     MLIRContext *ctx = dialectOp.getContext();
     StringRef dialectName = dialectOp.getName();
 
auto attrDef = DynamicAttrDefinition::get(
           return success();
         });
     attrDefs.try_emplace(attrOp, std::move(attrDef));
   });
   return attrDefs;
 }
 
 LogicalResult mlir::irdl::loadDialects(ModuleOp op) {
+  // First, check that all any_of constraints are in a correct form.
+  // This is to ensure we can do the verification correctly.
+  WalkResult anyOfCorrects =
+      op.walk([](AnyOf anyOf) { return (WalkResult)checkCorrectAnyOf(anyOf); });
+  if (anyOfCorrects.wasInterrupted())
+    return op.emitError("any_of constraints are not in the correct form");
+
   // Preallocate all dialects, and type and attribute definitions.
   // In particular, this allocates TypeIDs so type and attributes can have
   // verifiers that refer to each other.
   DenseMap<DialectOp, ExtensibleDialect *> dialects = loadEmptyDialects(op);
   DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> types =
       preallocateTypeDefs(op, dialects);
   DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> attrs =
       preallocateAttrDefs(op, dialects);

mlir/test/Dialect/IRDL/cmath.irdl.mlir

 // RUN: mlir-opt %s | mlir-opt | FileCheck %s
 
 module {
   // CHECK-LABEL: irdl.dialect @cmath {
   irdl.dialect @cmath {
 
     // CHECK: irdl.type @complex {
     // CHECK:   %[[v0:[^ ]*]] = irdl.is f32
-    // CHECK:   irdl.parameters(%[[v0]])
+    // CHECK:   %[[v1:[^ ]*]] = irdl.is f64
+    // CHECK:   %[[v2:[^ ]*]] = irdl.any_of(%[[v0]], %[[v1]])
+    // CHECK:   irdl.parameters(%[[v2]])
     // CHECK: }
     irdl.type @complex {
       %0 = irdl.is f32
-      irdl.parameters(%0)
+      %1 = irdl.is f64
+      %2 = irdl.any_of(%0, %1)
+      irdl.parameters(%2)
     }
 
     // CHECK: irdl.operation @norm {
     // CHECK:   %[[v0:[^ ]*]] = irdl.any
     // CHECK:   %[[v1:[^ ]*]] = irdl.parametric @complex<%[[v0]]>
     // CHECK:   irdl.operands(%[[v1]])
     // CHECK:   irdl.results(%[[v0]])
     // CHECK: }
     irdl.operation @norm {
       %0 = irdl.any
       %1 = irdl.parametric @complex<%0>
       irdl.operands(%1)
       irdl.results(%0)
     }
 
     // CHECK: irdl.operation @mul {
     // CHECK:   %[[v0:[^ ]*]] = irdl.is f32
-    // CHECK:   %[[v3:[^ ]*]] = irdl.parametric @complex<%[[v0]]>
+    // CHECK:   %[[v1:[^ ]*]] = irdl.is f64
+    // CHECK:   %[[v2:[^ ]*]] = irdl.any_of(%[[v0]], %[[v1]])
+    // CHECK:   %[[v3:[^ ]*]] = irdl.parametric @complex<%[[v2]]>
     // CHECK:   irdl.operands(%[[v3]], %[[v3]])
     // CHECK:   irdl.results(%[[v3]])
     // CHECK: }
     irdl.operation @mul {
       %0 = irdl.is f32
-      %3 = irdl.parametric @complex<%0>
+      %1 = irdl.is f64
+      %2 = irdl.any_of(%0, %1)
+      %3 = irdl.parametric @complex<%2>
       irdl.operands(%3, %3)
       irdl.results(%3)
     }
 
   }
 }

mlir/test/Dialect/IRDL/cyclic-types.irdl.mlir

+// RUN: mlir-opt %s | mlir-opt | FileCheck %s
+
+// Types that have cyclic references.
+
+// CHECK: irdl.dialect @testd {
+irdl.dialect @testd {
+  // CHECK:   irdl.type @self_referencing {
+  // CHECK:   %[[v0:[^ ]*]] = irdl.any
+  // CHECK:   %[[v1:[^ ]*]] = irdl.parametric @self_referencing<%[[v0]]>
+  // CHECK:   %[[v2:[^ ]*]] = irdl.is i32
+  // CHECK:   %[[v3:[^ ]*]] = irdl.any_of(%[[v1]], %[[v2]])
+  // CHECK:   irdl.parameters(%[[v3]])
+  // CHECK: }
+  irdl.type @self_referencing {
+    %0 = irdl.any
+    %1 = irdl.parametric @self_referencing<%0>
+    %2 = irdl.is i32
+    %3 = irdl.any_of(%1, %2)
+    irdl.parameters(%3)
+  }
+
+
+  // CHECK:   irdl.type @type1 {
+  // CHECK:   %[[v0:[^ ]*]] = irdl.any
+  // CHECK:   %[[v1:[^ ]*]] = irdl.parametric @type2<%[[v0]]>
+  // CHECK:   %[[v2:[^ ]*]] = irdl.is i32
+  // CHECK:   %[[v3:[^ ]*]] = irdl.any_of(%[[v1]], %[[v2]])
+  // CHECK:   irdl.parameters(%[[v3]])
+  irdl.type @type1 {
+    %0 = irdl.any
+    %1 = irdl.parametric @type2<%0>
+    %2 = irdl.is i32
+    %3 = irdl.any_of(%1, %2)
+    irdl.parameters(%3)
+  }
+
+  // CHECK:   irdl.type @type2 {
+  // CHECK:   %[[v0:[^ ]*]] = irdl.any
+  // CHECK:   %[[v1:[^ ]*]] = irdl.parametric @type1<%[[v0]]>
+  // CHECK:   %[[v2:[^ ]*]] = irdl.is i32
+  // CHECK:   %[[v3:[^ ]*]] = irdl.any_of(%[[v1]], %[[v2]])
+  // CHECK:   irdl.parameters(%[[v3]])
+  irdl.type @type2 {
+      %0 = irdl.any
+      %1 = irdl.parametric @type1<%0>
+      %2 = irdl.is i32
+      %3 = irdl.any_of(%1, %2)
+      irdl.parameters(%3)
+  }
+}

mlir/test/Dialect/IRDL/cyclic-types.mlir

+// RUN: mlir-opt %s --irdl-file=%S/cyclic-types.irdl.mlir -split-input-file -verify-diagnostics | FileCheck %s
+
+// Types that have cyclic references.
+
+// CHECK: !testd.self_referencing<i32>
+func.func @no_references(%v: !testd.self_referencing<i32>) {
+  return
+}
+
+// -----
+
+// CHECK: !testd.self_referencing<!testd.self_referencing<i32>>
+func.func @one_reference(%v: !testd.self_referencing<!testd.self_referencing<i32>>) {
+  return
+}
+
+// -----
+
+// expected-error@+1 {{'i64' does not satisfy the constraint}}
+func.func @wrong_parameter(%v: !testd.self_referencing<i64>) {
+  return
+}
+
+// -----
+
+// CHECK: !testd.type1<i32>
+func.func @type1_no_references(%v: !testd.type1<i32>) {
+  return
+}
+
+// -----
+
+// CHECK: !testd.type1<!testd.type2<i32>>
+func.func @type1_one_references(%v: !testd.type1<!testd.type2<i32>>) {
+  return
+}
+
+// -----
+
+// CHECK: !testd.type1<!testd.type2<!testd.type1<i32>>>
+func.func @type1_two_references(%v: !testd.type1<!testd.type2<!testd.type1<i32>>>) {
+  return
+}
+
+// -----
+
+// expected-error@+1 {{'i64' does not satisfy the constraint}}
+func.func @wrong_parameter_type1(%v: !testd.type1<i64>) {
+  return
+}
+
+// -----
+
+// expected-error@+1 {{'i64' does not satisfy the constraint}}
+func.func @wrong_parameter_type2(%v: !testd.type2<i64>) {
+  return
+}

mlir/test/Dialect/IRDL/test-type.irdl.mlir

+// RUN: mlir-opt %s | mlir-opt | FileCheck %s
+
+module {
+  // CHECK-LABEL: irdl.dialect @testd {
+  irdl.dialect @testd {
+    // CHECK: irdl.type @singleton
+    irdl.type @singleton
+
+    // CHECK: irdl.type @parametrized {
+    // CHECK:   %[[v0:[^ ]*]] = irdl.any
+    // CHECK:   %[[v1:[^ ]*]] = irdl.is i32
+    // CHECK:   %[[v2:[^ ]*]] = irdl.is i64
+    // CHECK:   %[[v3:[^ ]*]] = irdl.any_of(%[[v1]], %[[v2]])
+    // CHECK:   irdl.parameters(%[[v0]], %[[v3]])
+    // CHECK: }
+    irdl.type @parametrized {
+      %0 = irdl.any
+      %1 = irdl.is i32
+      %2 = irdl.is i64
+      %3 = irdl.any_of(%1, %2)
+      irdl.parameters(%0, %3)
+    }
+
+    // CHECK: irdl.operation @any {
+    // CHECK:   %[[v0:[^ ]*]] = irdl.any
+    // CHECK:   irdl.results(%[[v0]])
+    // CHECK: }
+    irdl.operation @any {
+      %0 = irdl.any
+      irdl.results(%0)
+    }
+  }
+}

mlir/test/Dialect/IRDL/test-type.mlir

+// RUN: mlir-opt %s --irdl-file=%S/test-type.irdl.mlir -split-input-file -verify-diagnostics | FileCheck %s
+
+func.func @succeededTypeVerifier() {
+    // CHECK: "testd.any"() : () -> !testd.singleton
+    "testd.any"() : () -> !testd.singleton
+
+    // CHECK-NEXT: "testd.any"() : () -> !testd.parametrized<f32, i32>
+    "testd.any"() : () -> !testd.parametrized<f32, i32>
+
+    // CHECK: "testd.any"() : () -> !testd.parametrized<i1, i64>
+    "testd.any"() : () -> !testd.parametrized<i1, i64>
+
+    return
+}
+
+// -----
+
+func.func @failedSingletonVerifier() {
+     // expected-error@+1 {{expected 0 type arguments, but had 1}}
+     "testd.any"() : () -> !testd.singleton<i32>
+}
+
+// -----
+
+func.func @failedParametrizedVerifierWrongNumOfArgs() {
+     // expected-error@+1 {{expected 2 type arguments, but had 1}}
+     "testd.any"() : () -> !testd.parametrized<i32>
+}
+
+// -----
+
+func.func @failedParametrizedVerifierWrongArgument() {
+     // expected-error@+1 {{'i1' does not satisfy the constraint}}
+     "testd.any"() : () -> !testd.parametrized<i32, i1>
+}

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

irdl.dialect @testd {
   // CHECK:   %[[v0:[^ ]*]] = irdl.is i32
   // CHECK:   irdl.results(%[[v0]])
   // CHECK: }
   irdl.operation @eq {
     %0 = irdl.is i32
     irdl.results(%0)
   }
 
+  // CHECK: irdl.operation @anyof {
+  // CHECK:   %[[v0:[^ ]*]] = irdl.is i32
+  // CHECK:   %[[v1:[^ ]*]] = irdl.is i64
+  // CHECK:   %[[v2:[^ ]*]] = irdl.any_of(%[[v0]], %[[v1]])
+  // CHECK:   irdl.results(%[[v2]])
+  // CHECK: }
+  irdl.operation @anyof {
+    %0 = irdl.is i32
+    %1 = irdl.is i64
+    %2 = irdl.any_of(%0, %1)
+    irdl.results(%2)
+  }
+
+  // CHECK: irdl.operation @all_of {
+  // CHECK:   %[[v0:[^ ]*]] = irdl.is i32
+  // CHECK:   %[[v1:[^ ]*]] = irdl.is i64
+  // CHECK:   %[[v2:[^ ]*]] = irdl.any_of(%[[v0]], %[[v1]])
+  // CHECK:   %[[v3:[^ ]*]] = irdl.all_of(%[[v2]], %[[v1]])
+  // CHECK:   irdl.results(%[[v3]])
+  // CHECK: }
+  irdl.operation @all_of {
+    %0 = irdl.is i32
+    %1 = irdl.is i64
+    %2 = irdl.any_of(%0, %1)
+    %3 = irdl.all_of(%2, %1)
+    irdl.results(%3)
+  }
+
   // CHECK: irdl.operation @any {
   // CHECK:   %[[v0:[^ ]*]] = irdl.any
   // CHECK:   irdl.results(%[[v0]])
   // CHECK: }
   irdl.operation @any {
     %0 = irdl.any
     irdl.results(%0)
   }
 
   // CHECK: irdl.operation @dynbase {
   // CHECK:   %[[v0:[^ ]*]] = irdl.any
   // CHECK:   %[[v1:[^ ]*]] = irdl.parametric @parametric<%[[v0]]>
   // CHECK:   irdl.results(%[[v1]])
   // CHECK: }
   irdl.operation @dynbase {
     %0 = irdl.any
     %1 = irdl.parametric @parametric<%0>
     irdl.results(%1)
   }
 
   // CHECK: irdl.operation @dynparams {
   // CHECK:   %[[v0:[^ ]*]] = irdl.is i32
-  // CHECK:   %[[v3:[^ ]*]] = irdl.parametric @parametric<%[[v0]]>
+  // CHECK:   %[[v1:[^ ]*]] = irdl.is i64
+  // CHECK:   %[[v2:[^ ]*]] = irdl.any_of(%[[v0]], %[[v1]])
+  // CHECK:   %[[v3:[^ ]*]] = irdl.parametric @parametric<%[[v2]]>
   // CHECK:   irdl.results(%[[v3]])
   // CHECK: }
   irdl.operation @dynparams {
     %0 = irdl.is i32
-    %3 = irdl.parametric @parametric<%0>
+    %1 = irdl.is i64
+    %2 = irdl.any_of(%0, %1)
+    %3 = irdl.parametric @parametric<%2>
     irdl.results(%3)
   }
 
   // CHECK: irdl.operation @constraint_vars {
-  // CHECK:   %[[v0:[^ ]*]] = irdl.any
-  // CHECK:   irdl.results(%[[v0]], %[[v0]])
+  // CHECK:   %[[v0:[^ ]*]] = irdl.is i32
+  // CHECK:   %[[v1:[^ ]*]] = irdl.is i64
+  // CHECK:   %[[v2:[^ ]*]] = irdl.any_of(%[[v0]], %[[v1]])
+  // CHECK:   irdl.results(%[[v2]], %[[v2]])
   // CHECK: }
   irdl.operation @constraint_vars {
-    %0 = irdl.any
-    irdl.results(%0, %0)
+    %0 = irdl.is i32
+    %1 = irdl.is i64
+    %2 = irdl.any_of(%0, %1)
+    irdl.results(%2, %2)
   }
 }

mlir/test/Dialect/IRDL/testd.mlir

func.func @failedEqConstraint() {
   // expected-error@+1 {{expected 'i32' but got 'i64'}}
   "testd.eq"() : () -> i64
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
+// AnyOf constraint
+//===----------------------------------------------------------------------===//
+
+func.func @succeededAnyOfConstraint() {
+  // CHECK: "testd.anyof"() : () -> i32
+  "testd.anyof"() : () -> i32
+  // CHECK: "testd.anyof"() : () -> i64
+  "testd.anyof"() : () -> i64
+  return
+}
+
+// -----
+
+func.func @failedAnyOfConstraint() {
+  // expected-error@+1 {{'i1' does not satisfy the constraint}}
+  "testd.anyof"() : () -> i1
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// AllOf constraint
+//===----------------------------------------------------------------------===//
+
+func.func @succeededAllOfConstraint() {
+  // CHECK: "testd.all_of"() : () -> i64
+  "testd.all_of"() : () -> i64
+  return
+}
+
+// -----
+
+func.func @failedAllOfConstraint1() {
+  // expected-error@+1 {{'i1' does not satisfy the constraint}}
+  "testd.all_of"() : () -> i1
+  return
+}
+
+// -----
+
+func.func @failedAllOfConstraint2() {
+  // expected-error@+1 {{expected 'i64' but got 'i32'}}
+  "testd.all_of"() : () -> i32
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
 // Any constraint
 //===----------------------------------------------------------------------===//
 
 func.func @succeededAnyConstraint() {
   // CHECK: "testd.any"() : () -> i32
   "testd.any"() : () -> i32
   // CHECK: "testd.any"() : () -> i64
   "testd.any"() : () -> i64
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // Dynamic base constraint
 //===----------------------------------------------------------------------===//
 
 func.func @succeededDynBaseConstraint() {
   // CHECK: "testd.dynbase"() : () -> !testd.parametric<i32>
   "testd.dynbase"() : () -> !testd.parametric<i32>
-  // CHECK: "testd.dynbase"() : () -> !testd.parametric<!testd.parametric<i32>>
-  "testd.dynbase"() : () -> !testd.parametric<!testd.parametric<i32>>
+  // CHECK: "testd.dynbase"() : () -> !testd.parametric<i64>
+  "testd.dynbase"() : () -> !testd.parametric<i64>
+  // CHECK: "testd.dynbase"() : () -> !testd.parametric<!testd.parametric<i64>>
+  "testd.dynbase"() : () -> !testd.parametric<!testd.parametric<i64>>
   return
 }
 
 // -----
 
 func.func @failedDynBaseConstraint() {
   // expected-error@+1 {{expected base type 'testd.parametric' but got 'i32'}}
   "testd.dynbase"() : () -> i32
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // Dynamic parameters constraint
 //===----------------------------------------------------------------------===//
 
 func.func @succeededDynParamsConstraint() {
   // CHECK: "testd.dynparams"() : () -> !testd.parametric<i32>
   "testd.dynparams"() : () -> !testd.parametric<i32>
+  // CHECK: "testd.dynparams"() : () -> !testd.parametric<i64>
+  "testd.dynparams"() : () -> !testd.parametric<i64>
   return
 }
 
 // -----
 
 func.func @failedDynParamsConstraintBase() {
   // expected-error@+1 {{expected base type 'testd.parametric' but got 'i32'}}
   "testd.dynparams"() : () -> i32
   return
 }
 
 // -----
 
 func.func @failedDynParamsConstraintParam() {
-  // expected-error@+1 {{expected 'i32' but got 'i1'}}
+  // expected-error@+1 {{'i1' does not satisfy the constraint}}
   "testd.dynparams"() : () -> !testd.parametric<i1>
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // Constraint variables