[mlir][ods] Rename Confined and AllAttrConstraintsOf

[Mogball]

Summary

Confined -> ConfinedAttr
AllAttrConstraintsOf -> AllOfAttr

To be in line with ConfinedType and AllOfType.

[rriddle]

Nice!

mlir/docs/OpDefinitions.md

def TF_AvgPoolOp : TF_Op<"AvgPool", [NoSideEffect]> {
   let description = [{
 Each entry in `output` is the mean of the corresponding size `ksize`
 window in `value`.
   }];
 
   let arguments = (ins
     TF_FpTensor:$value,
 
-    Confined<I64ArrayAttr, [ArrayMinCount<4>]>:$ksize,
-    Confined<I64ArrayAttr, [ArrayMinCount<4>]>:$strides,
+    ConfinedAttr<I64ArrayAttr, [ArrayMinCount<4>]>:$ksize,
+    ConfinedAttr<I64ArrayAttr, [ArrayMinCount<4>]>:$strides,
     TF_AnyStrAttrOf<["SAME", "VALID"]>:$padding,
     DefaultValuedAttr<TF_ConvertDataFormatAttr, "NHWC">:$data_format
   );
 
   let results = (outs
     TF_FpTensor:$output
   );
 

 
 The second parameter to `DefaultValuedAttr` should be a string containing the
 C++ default value. For example, a float default value should be specified as
 like `"0.5f"`, and an integer array default value should be specified as like
 `"{1, 2, 3}"`.
 
 #### Confining attributes
 
-`Confined` is provided as a general mechanism to help modelling further
+`ConfinedAttr` is provided as a general mechanism to help modelling further
 constraints on attributes beyond the ones brought by value types. You can use
-`Confined` to compose complex constraints out of more primitive ones. For
+`ConfinedAttr` to compose complex constraints out of more primitive ones. For
 example, a 32-bit integer attribute whose minimum value must be 10 can be
-expressed as `Confined<I32Attr, [IntMinValue<10>]>`.
+expressed as `ConfinedAttr<I32Attr, [IntMinValue<10>]>`.
 
 Right now, the following primitive constraints are supported:
 
 *   `IntMinValue<N>`: Specifying an integer attribute to be greater than or
     equal to `N`
 *   `IntMaxValue<N>`: Specifying an integer attribute to be less than or equal
     to `N`
 *   `ArrayMinCount<N>`: Specifying an array attribute to have at least `N`

 
 There are a few important attribute adapters/decorators/modifiers that can be
 applied to ODS attributes to specify common additional properties like
 optionality, default values, etc.:
 
 *   `DefaultValuedAttr`: specifies the
     [default value](#attributes-with-default-values) for an attribute.
 *   `OptionalAttr`: specifies an attribute as [optional](#optional-attributes).
-*   `Confined`: adapts an attribute with
+*   `ConfinedAttr`: adapts an attribute with
     [further constraints](#confining-attributes).
 
 ### Enum attributes
 
 Some attributes can only take values from a predefined enum, e.g., the
 comparison kind of a comparison op. To define such attributes, ODS provides
 several mechanisms: `IntEnumAttr`, and `BitEnumAttr`.
 

mlir/include/mlir/Dialect/Affine/IR/AffineOps.td

let description = [{
     specifier ranges from locality<0> (no locality) to locality<3> (extremely
     local keep in cache). The cache type specifier is either 'data' or 'instr'
     and specifies whether the prefetch is performed on data cache or on
     instruction cache.
   }];
 
   let arguments = (ins AnyMemRef:$memref, Variadic<Index>:$indices,
                    BoolAttr:$isWrite,
-                   Confined<I32Attr, [IntMinValue<0>,
+                   ConfinedAttr<I32Attr, [IntMinValue<0>,
                      IntMaxValue<3>]>:$localityHint,
                    BoolAttr:$isDataCache);
 
   let builders = [
     OpBuilder<(ins "Value":$memref, "AffineMap":$map,
       "ArrayRef<Value>":$mapOperands, "bool":$isWrite, "unsigned":$localityHint,
       "bool":$isDataCache),
     [{

mlir/include/mlir/Dialect/Async/IR/AsyncOps.td

 def Async_RuntimeAddRefOp : Async_Op<"runtime.add_ref"> {
   let summary = "adds a reference to async value";
   let description = [{
     The `async.runtime.add_ref` operation adds a reference(s) to async value
     (token, value or group).
   }];
 
   let arguments = (ins Async_AnyAsyncType:$operand,
-                       Confined<I64Attr, [IntPositive]>:$count);
+                       ConfinedAttr<I64Attr, [IntPositive]>:$count);
 
   let assemblyFormat = [{
     $operand attr-dict `:` type($operand)
   }];
 }
 
 def Async_RuntimeDropRefOp : Async_Op<"runtime.drop_ref"> {
   let summary = "drops a reference to async value";
   let description = [{
     The `async.runtime.drop_ref` operation drops a reference(s) to async value
     (token, value or group).
   }];
 
   let arguments = (ins Async_AnyAsyncType:$operand,
-                       Confined<I64Attr, [IntPositive]>:$count);
+                       ConfinedAttr<I64Attr, [IntPositive]>:$count);
 
   let assemblyFormat = [{
     $operand attr-dict `:` type($operand)
   }];
 }
 
 def Async_RuntimeNumWorkerThreadsOp :
   Async_Op<"runtime.num_worker_threads",

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

let arguments = (ins
     TypeAttr:$global_type,
     UnitAttr:$constant,
     StrAttr:$sym_name,
     Linkage:$linkage,
     UnitAttr:$dso_local,
     UnitAttr:$thread_local_,
     OptionalAttr<AnyAttr>:$value,
     OptionalAttr<I64Attr>:$alignment,
-    DefaultValuedAttr<Confined<I32Attr, [IntNonNegative]>, "0">:$addr_space,
+    DefaultValuedAttr<ConfinedAttr<I32Attr, [IntNonNegative]>, "0">:$addr_space,
     OptionalAttr<UnnamedAddr>:$unnamed_addr,
     OptionalAttr<StrAttr>:$section
   );
   let summary = "LLVM dialect global.";
   let description = [{
     Since MLIR allows for arbitrary operations to be present at the top level,
     global variables are defined using the `llvm.mlir.global` operation. Both
     global constants and variables can be defined, and the value may also be

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

let description = [{
     ```
   }];
   let builders = [OpBuilder<(ins), [{ /* nothing to do */ }]>];
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
 def Linalg_IndexOp : Linalg_Op<"index", [NoSideEffect]>,
-    Arguments<(ins Confined<I64Attr, [IntMinValue<0>]>:$dim)>,
+    Arguments<(ins ConfinedAttr<I64Attr, [IntMinValue<0>]>:$dim)>,
     Results<(outs Index:$result)> {
   let summary = "linalg index operation";
   let description = [{
     The `linalg.index` operation returns the iteration index of the immediately
     enclosing linalg structured operation for the iteration dimension `dim`. The
     `dim` attribute specifies the position of the accessed dimension in the
     indexing map domain.
 

mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

class AllocLikeOp<string mnemonic,
     !listconcat([
       AttrSizedOperandSegments
     ], traits)> {
 
   let arguments = (ins Variadic<Index>:$dynamicSizes,
                        // The symbolic operands (the ones in square brackets)
                        // bind to the symbols of the memref's layout map.
                        Variadic<Index>:$symbolOperands,
-                       Confined<OptionalAttr<I64Attr>,
+                       ConfinedAttr<OptionalAttr<I64Attr>,
                                 [IntMinValue<0>]>:$alignment);
   let results = (outs Res<AnyMemRef, "", [MemAlloc<resource>]>:$memref);
 
   let builders = [
     OpBuilder<(ins "MemRefType":$memrefType,
                   CArg<"IntegerAttr", "IntegerAttr()">:$alignment), [{
       return build($_builder, $_state, memrefType, {}, alignment);
     }]>,
let description = [{
     The `assume_alignment` operation takes a memref and an integer of alignment
     value, and internally annotates the buffer with the given alignment. If
     the buffer isn't aligned to the given alignment, the behavior is undefined.
 
     This operation doesn't affect the semantics of a correct program. It's for
     optimization only, and the optimization is best-effort.
   }];
   let arguments = (ins AnyMemRef:$memref,
-                       Confined<I32Attr, [IntPositive]>:$alignment);
+                       ConfinedAttr<I32Attr, [IntPositive]>:$alignment);
   let results = (outs);
 
   let assemblyFormat = "$memref `,` $alignment attr-dict `:` type($memref)";
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AllocOp
let description = [{
     ranges from locality<0> (no locality) to locality<3> (extremely local keep
     in cache). The cache type specifier is either 'data' or 'instr'
     and specifies whether the prefetch is performed on data cache or on
     instruction cache.
   }];
 
   let arguments = (ins AnyMemRef:$memref, Variadic<Index>:$indices,
                        BoolAttr:$isWrite,
-                       Confined<I32Attr, [IntMinValue<0>,
+                       ConfinedAttr<I32Attr, [IntMinValue<0>,
                                           IntMaxValue<3>]>:$localityHint,
                        BoolAttr:$isDataCache);
 
   let extraClassDeclaration = [{
     MemRefType getMemRefType() {
       return getMemref().getType().cast<MemRefType>();
     }
     static StringRef getLocalityHintAttrStrName() { return "localityHint"; }

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

 
 //===----------------------------------------------------------------------===//
 // 2.8.2 Single Construct
 //===----------------------------------------------------------------------===//
 
 def SingleOp : OpenMP_Op<"single", [AttrSizedOperandSegments]> {
   let summary = "single directive";
   let description = [{
-    The single construct specifies that the associated structured block is 
+    The single construct specifies that the associated structured block is
     executed by only one of the threads in the team (not necessarily the
     master thread), in the context of its implicit task. The other threads
     in the team, which do not execute the block, wait at an implicit barrier
     at the end of the single construct unless a nowait clause is specified.
   }];
 
   let arguments = (ins Variadic<AnyType>:$allocate_vars,
                        Variadic<AnyType>:$allocators_vars,
let arguments = (ins Variadic<IntLikeType>:$lowerBound,
              Variadic<I32>:$linear_step_vars,
              Variadic<OpenMP_PointerLikeType>:$reduction_vars,
              OptionalAttr<SymbolRefArrayAttr>:$reductions,
              OptionalAttr<ScheduleKindAttr>:$schedule_val,
              Optional<AnyType>:$schedule_chunk_var,
              OptionalAttr<ScheduleModifierAttr>:$schedule_modifier,
              UnitAttr:$simd_modifier,
              UnitAttr:$nowait,
-             Confined<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$ordered_val,
+             ConfinedAttr<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$ordered_val,
              OptionalAttr<OrderKindAttr>:$order_val,
              UnitAttr:$inclusive);
 
   let builders = [
     OpBuilder<(ins "ValueRange":$lowerBound, "ValueRange":$upperBound,
                "ValueRange":$step,
                CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>,
   ];
oilist(`linear` `(`
               ) `)`
     ) `for` custom<LoopControl>($region, $lowerBound, $upperBound, $step,
                                   type($step), $inclusive) attr-dict
   }];
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
-// Simd construct [2.9.3.1] 
+// Simd construct [2.9.3.1]
 //===----------------------------------------------------------------------===//
 
 def SimdLoopOp : OpenMP_Op<"simdloop", [AttrSizedOperandSegments,
                          AllTypesMatch<["lowerBound", "upperBound", "step"]>]> {
  let summary = "simd loop construct";
   let description = [{
-    The simd construct can be applied to a loop to indicate that the loop can be 
-    transformed into a SIMD loop (that is, multiple iterations of the loop can 
-    be executed concurrently using SIMD instructions).. The lower and upper 
-    bounds specify a half-open range: the range includes the lower bound but 
+    The simd construct can be applied to a loop to indicate that the loop can be
+    transformed into a SIMD loop (that is, multiple iterations of the loop can
+    be executed concurrently using SIMD instructions).. The lower and upper
+    bounds specify a half-open range: the range includes the lower bound but
     does not include the upper bound. If the `inclusive` attribute is specified
     then the upper bound is also included.
 
     The body region can contain any number of blocks. The region is terminated
     by "omp.yield" instruction without operands.
 
     When an if clause is present and evaluates to false, the preferred number of
     iterations to be executed concurrently is one, regardless of whether
     a simdlen clause is specified.
 
     When a simdlen clause is present, the preferred number of iterations to be
     executed concurrently is the value provided to the simdlen clause.
     ```
     omp.simdloop <clauses>
     for (%i1, %i2) : index = (%c0, %c0) to (%c10, %c10) step (%c1, %c1) {
       // block operations
       omp.yield
     }
-    ``` 
+    ```
   }];
 
   // TODO: Add other clauses
   let arguments = (ins Variadic<IntLikeType>:$lowerBound,
              Variadic<IntLikeType>:$upperBound,
              Variadic<IntLikeType>:$step,
              Optional<I1>:$if_expr,
-             Confined<OptionalAttr<I64Attr>, [IntPositive]>:$simdlen,
+             ConfinedAttr<OptionalAttr<I64Attr>, [IntPositive]>:$simdlen,
              UnitAttr:$inclusive
      );
- 
   let regions = (region AnyRegion:$region);
   let assemblyFormat = [{
     oilist(`if` `(` $if_expr `)`
           |`simdlen` `(` $simdlen  `)`
     ) `for` custom<LoopControl>($region, $lowerBound, $upperBound, $step,
                                   type($step), $inclusive) attr-dict
   }];
 
   let extraClassDeclaration = [{
     /// Returns the number of loops in the simd loop nest.
     unsigned getNumLoops() { return lowerBound().size(); }
 
   }];
- 
   let hasCustomAssemblyFormat = 1;
-  let hasVerifier = 1; 
+  let hasVerifier = 1;
 }
 
 
 def YieldOp : OpenMP_Op<"yield",
     [NoSideEffect, ReturnLike, Terminator,
-     ParentOneOf<["WsLoopOp", "ReductionDeclareOp", 
+     ParentOneOf<["WsLoopOp", "ReductionDeclareOp",
      "AtomicUpdateOp", "SimdLoopOp"]>]> {
   let summary = "loop yield and termination operation";
   let description = [{
     "omp.yield" yields SSA values from the OpenMP dialect op region and
     terminates the region. The semantics of how the values are yielded is
     defined by the parent operation.
   }];
 
let description = [{
     The `depend_vec_vars` is a variadic list of operands that specifies the index
     of the loop iterator in the doacross nest for the DEPEND(SOURCE) clause or
     the index of the element of "vec" for the DEPEND(SINK: vec) clause. It
     contains the operands in multiple "vec" when multiple DEPEND(SINK: vec)
     clauses exist in one ORDERED directive.
   }];
 
   let arguments = (ins OptionalAttr<ClauseDependAttr>:$depend_type_val,
-             Confined<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$num_loops_val,
+             ConfinedAttr<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$num_loops_val,
              Variadic<AnyType>:$depend_vec_vars);
 
   let assemblyFormat = [{
     ( `depend_type` `` $depend_type_val^ )?
     ( `depend_vec` `(` $depend_vec_vars^ `:` type($depend_vec_vars) `)` )?
     attr-dict
   }];
   let hasVerifier = 1;
let description = [{
     can be one of `seq_cst`, `acquire` or `relaxed`.
   }];
 
   let arguments = (ins OpenMP_PointerLikeType:$x,
                        OpenMP_PointerLikeType:$v,
                        DefaultValuedAttr<I64Attr, "0">:$hint_val,
                        OptionalAttr<MemoryOrderKindAttr>:$memory_order_val);
   let assemblyFormat = [{
-    $v `=` $x 
+    $v `=` $x
     oilist( `memory_order` `(` custom<ClauseAttr>($memory_order_val) `)`
           | `hint` `(` custom<SynchronizationHint>($hint_val) `)`)
     `:` type($x) attr-dict
   }];
   let hasVerifier = 1;
   let extraClassDeclaration = [{
     /// The number of variable operands.
     unsigned getNumVariableOperands() {
let assemblyFormat = [{ `cancellation_construct_type` `(`
                            attr-dict}];
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.19.5.7 declare reduction Directive
 //===----------------------------------------------------------------------===//
 
-def ReductionDeclareOp : OpenMP_Op<"reduction.declare", [Symbol, 
+def ReductionDeclareOp : OpenMP_Op<"reduction.declare", [Symbol,
                                                          IsolatedFromAbove]> {
   let summary = "declares a reduction kind";
 
   let description = [{
     Declares an OpenMP reduction kind. This requires two mandatory and one
     optional region.
 
       1. The initializer region specifies how to initialize the thread-local

mlir/include/mlir/Dialect/PDL/IR/PDLOps.td

OpBuilder<(ins CArg<"Optional<StringRef>", "llvm::None">:$name,
             operandValues, attrValues, $_builder.getStrArrayAttr(attrNames),
             resultTypes);
     }]>,
   ];
   let extraClassDeclaration = [{
     /// Returns true if the operation type referenced supports result type
     /// inference.
     bool hasTypeInference();
-    
     /// Returns true if the operation type referenced might support result type
     /// inference, i.e. it supports type reference or is currently not
     /// registered in the context. Returns false if the root operation name
     /// has not been set.
     bool mightHaveTypeInference();
   }];
   let hasVerifier = 1;
 }
pdl.pattern : benefit(1) {
       %root = pdl.operation "foo.op"(%inputOperand) -> (%resultType)
       pdl.rewrite %root {
         pdl.replace %root with (%inputOperand)
       }
     }
     ```
   }];
 
-  let arguments = (ins Confined<I16Attr, [IntNonNegative]>:$benefit,
+  let arguments = (ins ConfinedAttr<I16Attr, [IntNonNegative]>:$benefit,
                        OptionalAttr<SymbolNameAttr>:$sym_name);
   let regions = (region SizedRegion<1>:$body);
   let assemblyFormat = [{
     ($sym_name^)? `:` `benefit` `(` $benefit `)` attr-dict-with-keyword $body
   }];
 
   let builders = [
     OpBuilder<(ins CArg<"Optional<uint16_t>", "1">:$benefit,

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

let description = [{
     pdl_interp.check_operand_count of %op is 2 -> ^matchDest, ^failureDest
 
     // Check for at least N operands.
     pdl_interp.check_operand_count of %op is at_least 2 -> ^matchDest, ^failureDest
     ```
   }];
 
   let arguments = (ins PDL_Operation:$inputOp,
-                       Confined<I32Attr, [IntNonNegative]>:$count,
+                       ConfinedAttr<I32Attr, [IntNonNegative]>:$count,
                        UnitAttr:$compareAtLeast);
   let assemblyFormat = [{
     `of` $inputOp `is` (`at_least` $compareAtLeast^)? $count attr-dict
     `->` successors
   }];
 }
 
 //===----------------------------------------------------------------------===//
let description = [{
     pdl_interp.check_result_count of %op is 2 -> ^matchDest, ^failureDest
 
     // Check for at least N results.
     pdl_interp.check_result_count of %op is at_least 2 -> ^matchDest, ^failureDest
     ```
   }];
 
   let arguments = (ins PDL_Operation:$inputOp,
-                       Confined<I32Attr, [IntNonNegative]>:$count,
+                       ConfinedAttr<I32Attr, [IntNonNegative]>:$count,
                        UnitAttr:$compareAtLeast);
   let assemblyFormat = [{
     `of` $inputOp `is` (`at_least` $compareAtLeast^)? $count attr-dict
     `->` successors
   }];
 }
 
 //===----------------------------------------------------------------------===//
let description = [{
 
     ```mlir
     // Extract the value at index 1 from a range of values.
     %ops = pdl_interp.extract 1 of %values : !pdl.value
     ```
   }];
 
   let arguments = (ins PDL_RangeOf<PDL_AnyType>:$range,
-                       Confined<I32Attr, [IntNonNegative]>:$index);
+                       ConfinedAttr<I32Attr, [IntNonNegative]>:$index);
   let results = (outs PDL_AnyType:$result);
   let assemblyFormat = "$index `of` $range `:` type($result) attr-dict";
 
   let builders = [
     OpBuilder<(ins "Value":$range, "unsigned":$index), [{
       build($_builder, $_state,
             range.getType().cast<pdl::RangeType>().getElementType(),
             range, index);
let description = [{
     Example:
 
     ```mlir
     %operand = pdl_interp.get_operand 1 of %op
     ```
   }];
 
   let arguments = (ins PDL_Operation:$inputOp,
-                       Confined<I32Attr, [IntNonNegative]>:$index);
+                       ConfinedAttr<I32Attr, [IntNonNegative]>:$index);
   let results = (outs PDL_Value:$value);
   let assemblyFormat = "$index `of` $inputOp attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetOperandsOp
 //===----------------------------------------------------------------------===//
 
let description = [{
 
     // Get all of the operands from an operation.
     %operands = pdl_interp.get_operands of %op : !pdl.range<value>
     ```
   }];
 
   let arguments = (ins
     PDL_Operation:$inputOp,
-    OptionalAttr<Confined<I32Attr, [IntNonNegative]>>:$index
+    OptionalAttr<ConfinedAttr<I32Attr, [IntNonNegative]>>:$index
   );
   let results = (outs PDL_InstOrRangeOf<PDL_Value>:$value);
   let assemblyFormat = "($index^)? `of` $inputOp `:` type($value) attr-dict";
   let builders = [
     OpBuilder<(ins "Type":$resultType, "Value":$inputOp,
                    "Optional<unsigned>":$index), [{
       build($_builder, $_state, resultType, inputOp,
             index ? $_builder.getI32IntegerAttr(*index) : IntegerAttr());
let description = [{
     Example:
 
     ```mlir
     %result = pdl_interp.get_result 1 of %op
     ```
   }];
 
   let arguments = (ins PDL_Operation:$inputOp,
-                       Confined<I32Attr, [IntNonNegative]>:$index);
+                       ConfinedAttr<I32Attr, [IntNonNegative]>:$index);
   let results = (outs PDL_Value:$value);
   let assemblyFormat = "$index `of` $inputOp attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetResultsOp
 //===----------------------------------------------------------------------===//
 
let description = [{
 
     // Get all of the results from an operation.
     %results = pdl_interp.get_results of %op : !pdl.range<value>
     ```
   }];
 
   let arguments = (ins
     PDL_Operation:$inputOp,
-    OptionalAttr<Confined<I32Attr, [IntNonNegative]>>:$index
+    OptionalAttr<ConfinedAttr<I32Attr, [IntNonNegative]>>:$index
   );
   let results = (outs PDL_InstOrRangeOf<PDL_Value>:$value);
   let assemblyFormat = "($index^)? `of` $inputOp `:` type($value) attr-dict";
   let builders = [
     OpBuilder<(ins "Type":$resultType, "Value":$inputOp,
                    "Optional<unsigned>":$index), [{
       build($_builder, $_state, resultType, inputOp,
             index ? $_builder.getI32IntegerAttr(*index) : IntegerAttr());
let description = [{
     ```
   }];
 
   let arguments = (ins Variadic<PDL_AnyType>:$inputs,
                        Variadic<PDL_Operation>:$matchedOps,
                        SymbolRefAttr:$rewriter,
                        OptionalAttr<StrAttr>:$rootKind,
                        OptionalAttr<StrArrayAttr>:$generatedOps,
-                       Confined<I16Attr, [IntNonNegative]>:$benefit);
+                       ConfinedAttr<I16Attr, [IntNonNegative]>:$benefit);
   let successors = (successor AnySuccessor:$dest);
   let assemblyFormat = [{
     $rewriter (`(` $inputs^ `:` type($inputs) `)`)? `:`
     `benefit` `(` $benefit `)` `,`
     (`generatedOps` `(` $generatedOps^ `)` `,`)?
     `loc` `(` `[` $matchedOps `]` `)`
     (`,` `root` `(` $rootKind^ `)`)? attr-dict `->` $dest
   }];

mlir/include/mlir/Dialect/SCF/TransformOps/SCFTransformOps.td

let description = [{
     cannot be found. The list of operations associated with the handle contains
     parent operations in the same order as the list associated with the operand,
     except for operations that are parents to more than one input which are only
     present once.
   }];
 
   let arguments =
     (ins PDL_Operation:$target,
-         DefaultValuedAttr<Confined<I64Attr, [IntPositive]>,
+         DefaultValuedAttr<ConfinedAttr<I64Attr, [IntPositive]>,
                            "1">:$num_loops);
   let results = (outs PDL_Operation:$parent);
 
   let assemblyFormat = "$target attr-dict";
 }
 
 def LoopOutlineOp : Op<Transform_Dialect, "loop.outline",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
def LoopPeelOp : Op<Transform_Dialect, "loop.peel",
   let description = [{
      Updates the given loop so that its step evenly divides its range and puts
      the remaining iteration into a separate loop or a conditional.
 
      In the absence of sufficient static information, this op may peel a loop,
      even if the step always divides the range evenly at runtime.
 
      #### Return modes
-     
      This operation ignores non-scf::ForOp ops and drops them in the return.
 
      This operation always succeeds and returns the scf::ForOp with the
      postcondition: "the loop trip count is divisible by the step".
      This operation may return the same unmodified loop handle when peeling did
      not modify the IR (i.e. the loop trip count was already divisible).
 
      Note that even though the Payload IR modification may be performed
      in-place, this operation consumes the operand handle and produces a new
      one.
 
      TODO: Return both the peeled loop and the remainder loop.
   }];
 
   let arguments =
       (ins PDL_Operation:$target,
            DefaultValuedAttr<BoolAttr, "false">:$fail_if_already_divisible);
-  // TODO: Return both the peeled loop and the remainder loop. 
+  // TODO: Return both the peeled loop and the remainder loop.
   let results = (outs PDL_Operation:$transformed);
 
   let assemblyFormat = "$target attr-dict";
 
   let extraClassDeclaration = [{
     ::mlir::DiagnosedSilenceableFailure applyToOne(
-        ::mlir::scf::ForOp target, 
-        ::llvm::SmallVector<::mlir::Operation *> &results, 
+        ::mlir::scf::ForOp target,
+        ::llvm::SmallVector<::mlir::Operation *> &results,
         ::mlir::transform::TransformState &state);
   }];
 }
- 
 def LoopPipelineOp : Op<Transform_Dialect, "loop.pipeline",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      TransformOpInterface, TransformEachOpTrait]> {
   let summary = "Applies software pipelining to the loop";
   let description = [{
     Transforms the given loops one by one to achieve software pipelining for
     each of them. That is, performs some amount of reads from memory before the
     loop rather than inside the loop, the same amount of writes into memory
     after the loop, and updates each iteration to read the data for a following
-    iteration rather than the current one. 
-    
-    The amount is specified by the attributes. 
-    
+    iteration rather than the current one.
+    The amount is specified by the attributes.
     The values read and about to be stored are transferred as loop iteration
-    arguments. Currently supports memref and vector transfer operations as 
+    arguments. Currently supports memref and vector transfer operations as
     memory reads/writes.
 
     #### Return modes
-    
     This operation ignores non-scf::For ops and drops them in the return.
     If all the operations referred to by the `target` PDLOperation pipeline
     properly, the transform succeeds. Otherwise the transform silently fails.
-    The return handle points to only the subset of successfully produced 
+    The return handle points to only the subset of successfully produced
     pipelined loops, which can be empty.
   }];
 
   let arguments = (ins PDL_Operation:$target,
                    DefaultValuedAttr<I64Attr, "1">:$iteration_interval,
                    DefaultValuedAttr<I64Attr, "10">:$read_latency);
   let results = (outs PDL_Operation:$transformed);
 
   let assemblyFormat = "$target attr-dict";
 
   let extraClassDeclaration = [{
     ::mlir::DiagnosedSilenceableFailure applyToOne(
-        ::mlir::scf::ForOp target, 
-        ::llvm::SmallVector<::mlir::Operation *> &results, 
+        ::mlir::scf::ForOp target,
+        ::llvm::SmallVector<::mlir::Operation *> &results,
         ::mlir::transform::TransformState &state);
   }];
 }
 
 def LoopUnrollOp : Op<Transform_Dialect, "loop.unroll",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      TransformOpInterface, TransformEachOpTrait]> {
   let summary = "Unrolls the given loop with the given unroll factor";
   let description = [{
     Unrolls each loop associated with the given handle to have up to the given
     number of loop body copies per iteration. If the unroll factor is larger
     than the loop trip count, the latter is used as the unroll factor instead.
 
     #### Return modes
-    
     This operation ignores non-scf::For ops and drops them in the return.
     If all the operations referred to by the `target` PDLOperation unroll
     properly, the transform succeeds. Otherwise the transform silently fails.
-    
     Does not return handles as the operation may result in the loop being
     removed after a full unrolling.
   }];
 
   let arguments = (ins PDL_Operation:$target,
-                       Confined<I64Attr, [IntPositive]>:$factor);
+                       ConfinedAttr<I64Attr, [IntPositive]>:$factor);
 
   let assemblyFormat = "$target attr-dict";
 
   let extraClassDeclaration = [{
     ::mlir::DiagnosedSilenceableFailure applyToOne(
-        ::mlir::scf::ForOp target, 
-        ::llvm::SmallVector<::mlir::Operation *> &results, 
+        ::mlir::scf::ForOp target,
+        ::llvm::SmallVector<::mlir::Operation *> &results,
         ::mlir::transform::TransformState &state);
   }];
 }
 
 #endif // SCF_TRANSFORM_OPS

mlir/include/mlir/Dialect/Tosa/IR/TosaTypesBase.td

 
 //===----------------------------------------------------------------------===//
 // Tensor types
 //===----------------------------------------------------------------------===//
 
 def Tosa_Int32Tensor : TensorOf<[Tosa_Int32]>;
 def Tosa_Int32Or64Tensor : TensorOf<[Tosa_Int32Or64]>;
 
-// Either ranked or unranked tensor of TOSA supported element types. 
+// Either ranked or unranked tensor of TOSA supported element types.
 def Tosa_Tensor : TensorOf<[Tosa_AnyNumber]>;
 // Must be ranked but no further constraints
 def Tosa_RankedTensor : RankedTensorOf<[Tosa_AnyNumber]>;
 
 // Any tensor element type allowed in Tosa ops.
 def Tosa_ElementType : Type<Or<[Tosa_Int.predicate, Tosa_QuantizedInt.predicate,
                                 Tosa_Float.predicate]>, "tosa.dtype">;
 

 
 //===----------------------------------------------------------------------===//
 // Attribute predicates and classes.
 //===----------------------------------------------------------------------===//
 class ArrayMaxCt<int n> : AttrConstraint<
     CPred<"$_self.cast<::mlir::ArrayAttr>().size() <= " # n>,
     "with at least " # n # " elements">;
 
-def Tosa_Fp32ArrayAttr2 : Confined<F32ArrayAttr, [ArrayCount<2>]>;
-def Tosa_Fp32ArrayAttr3 : Confined<F32ArrayAttr, [ArrayCount<3>]>;
-def Tosa_Fp32ArrayAttr4 : Confined<F32ArrayAttr, [ArrayCount<4>]>;
-def Tosa_Fp32ArrayAttr5 : Confined<F32ArrayAttr, [ArrayCount<5>]>;
-def Tosa_Fp32ArrayAttr6 : Confined<F32ArrayAttr, [ArrayCount<6>]>;
-
-def Tosa_IntArrayAttr2 : Confined<I64ArrayAttr, [ArrayCount<2>]>;
-def Tosa_IntArrayAttr3 : Confined<I64ArrayAttr, [ArrayCount<3>]>;
-def Tosa_IntArrayAttr4 : Confined<I64ArrayAttr, [ArrayCount<4>]>;
-def Tosa_IntArrayAttr5 : Confined<I64ArrayAttr, [ArrayCount<5>]>;
-def Tosa_IntArrayAttr6 : Confined<I64ArrayAttr, [ArrayCount<6>]>;
-
-def Tosa_IntArrayAttrUpto2 : Confined<I64ArrayAttr, [ArrayMaxCt<2>]>;
-def Tosa_IntArrayAttrUpto4 : Confined<I64ArrayAttr, [ArrayMaxCt<4>]>;
-def Tosa_IntArrayAttrUpto5 : Confined<I64ArrayAttr, [ArrayMaxCt<5>]>;
+def Tosa_Fp32ArrayAttr2 : ConfinedAttr<F32ArrayAttr, [ArrayCount<2>]>;
+def Tosa_Fp32ArrayAttr3 : ConfinedAttr<F32ArrayAttr, [ArrayCount<3>]>;
+def Tosa_Fp32ArrayAttr4 : ConfinedAttr<F32ArrayAttr, [ArrayCount<4>]>;
+def Tosa_Fp32ArrayAttr5 : ConfinedAttr<F32ArrayAttr, [ArrayCount<5>]>;
+def Tosa_Fp32ArrayAttr6 : ConfinedAttr<F32ArrayAttr, [ArrayCount<6>]>;
+
+def Tosa_IntArrayAttr2 : ConfinedAttr<I64ArrayAttr, [ArrayCount<2>]>;
+def Tosa_IntArrayAttr3 : ConfinedAttr<I64ArrayAttr, [ArrayCount<3>]>;
+def Tosa_IntArrayAttr4 : ConfinedAttr<I64ArrayAttr, [ArrayCount<4>]>;
+def Tosa_IntArrayAttr5 : ConfinedAttr<I64ArrayAttr, [ArrayCount<5>]>;
+def Tosa_IntArrayAttr6 : ConfinedAttr<I64ArrayAttr, [ArrayCount<6>]>;
+
+def Tosa_IntArrayAttrUpto2 : ConfinedAttr<I64ArrayAttr, [ArrayMaxCt<2>]>;
+def Tosa_IntArrayAttrUpto4 : ConfinedAttr<I64ArrayAttr, [ArrayMaxCt<4>]>;
+def Tosa_IntArrayAttrUpto5 : ConfinedAttr<I64ArrayAttr, [ArrayMaxCt<5>]>;
 
 //===----------------------------------------------------------------------===//
 // Iterable attributes.
 //===----------------------------------------------------------------------===//
 // Supported regimes for tosa.resize.
 def Tosa_ResizeTypeAttr : StringBasedAttr<
     CPred<"$_self.cast<StringAttr>().getValue() == \"BILINEAR\"  || " #
           "$_self.cast<StringAttr>().getValue() == \"NEAREST_NEIGHBOR\"">,

mlir/include/mlir/IR/OpBase.td

 class UnrankedTensorOf<list<Type> allowedTypes>
   : ShapedContainerType<allowedTypes, IsUnrankedTensorTypePred,
       "unranked.tensor", "::mlir::UnrankedTensorType">;
 
 // Any tensor type whose element type is from the given `allowedTypes`
 // list, and which additionally satisfies an optional list of predicates.
 //
 // TODO: use `Constraint` instead of `Pred`, so we can generate a better
-// default summary (a la `Confined`).
+// default summary (a la `ConfinedAttr`).
 class TensorOf<
     list<Type> allowedTypes,
     list<Pred> preds = [],
     string summary = "tensor">
   : ShapedContainerType<allowedTypes,
       And<!listconcat([IsTensorTypePred], preds)>,
       summary, "::mlir::TensorType">;
 

 
 //===----------------------------------------------------------------------===//
 // Common attribute constraints
 //===----------------------------------------------------------------------===//
 
 // A general mechanism to further confine the given `attr` with all the
 // `constraints`. This allows to compose complex constraints out of a series
 // of more primitive ones.
-class Confined<Attr attr, list<AttrConstraint> constraints> : Attr<
+class ConfinedAttr<Attr attr, list<AttrConstraint> constraints> : Attr<
     And<!listconcat([attr.predicate],
                       !foreach(pred, constraints, pred.predicate))>,
     !foldl(/*init*/attr.summary, /*list*/constraints,
            prev, cur, prev # " " # cur.summary)> {
   let storageType = attr.storageType;
   let returnType = attr.returnType;
   let convertFromStorage = attr.convertFromStorage;
   let constBuilderCall = attr.constBuilderCall;
   let defaultValue = attr.defaultValue;
   let valueType = attr.valueType;
   let isOptional = attr.isOptional;
 
   let baseAttr = attr;
 }
 
 // An AttrConstraint that holds if all attr constraints specified in
 // 'constraints' hold.
-class AllAttrConstraintsOf<list<AttrConstraint> constraints> : AttrConstraint<
+class AllAttrOf<list<AttrConstraint> constraints> : AttrConstraint<
     And<!listconcat([!head(constraints).predicate],
-                      !foreach(pred, !tail(constraints), pred.predicate))>,
     !interleave(!foreach(con, constraints, con.summary), " and ")> {
 }
 
 class IntMinValue<int n> : AttrConstraint<
     CPred<"$_self.cast<::mlir::IntegerAttr>().getInt() >= " # n>,
     "whose minimum value is " # n>;
 
 class IntMaxValue<int n> : AttrConstraint<

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

void InsertStridedSliceOp::build(OpBuilder &builder, OperationState &result,
   result.addOperands({source, dest});
   auto offsetsAttr = getVectorSubscriptAttr(builder, offsets);
   auto stridesAttr = getVectorSubscriptAttr(builder, strides);
   result.addTypes(dest.getType());
   result.addAttribute(getOffsetsAttrStrName(), offsetsAttr);
   result.addAttribute(getStridesAttrStrName(), stridesAttr);
 }
 
-// TODO: Should be moved to Tablegen Confined attributes.
+// TODO: Should be moved to Tablegen ConfinedAttr attributes.
 template <typename OpType>
 static LogicalResult isIntegerArrayAttrSmallerThanShape(OpType op,
                                                         ArrayAttr arrayAttr,
                                                         ArrayRef<int64_t> shape,
                                                         StringRef attrName) {
   if (arrayAttr.size() > shape.size())
     return op.emitOpError("expected ")
            << attrName << " attribute of rank smaller than vector rank";

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

 //===----------------------------------------------------------------------===//
 
 def AnyAttrOfOp : TEST_Op<"any_attr_of_i32_str"> {
   let arguments = (ins AnyAttrOf<[I32Attr, StrAttr]>:$attr);
 }
 
 def NonNegIntAttrOp : TEST_Op<"non_negative_int_attr"> {
   let arguments = (ins
-      Confined<I32Attr, [IntNonNegative]>:$i32attr,
-      Confined<I64Attr, [IntNonNegative]>:$i64attr
+      ConfinedAttr<I32Attr, [IntNonNegative]>:$i32attr,
+      ConfinedAttr<I64Attr, [IntNonNegative]>:$i64attr
   );
 }
 
 def PositiveIntAttrOp : TEST_Op<"positive_int_attr"> {
   let arguments = (ins
-      Confined<I32Attr, [IntPositive]>:$i32attr,
-      Confined<I64Attr, [IntPositive]>:$i64attr
+      ConfinedAttr<I32Attr, [IntPositive]>:$i32attr,
+      ConfinedAttr<I64Attr, [IntPositive]>:$i64attr
   );
 }
 
 def TypeArrayAttrOp : TEST_Op<"type_array_attr"> {
   let arguments = (ins TypeArrayAttr:$attr);
 }
 def TypeArrayAttrWithDefaultOp : TEST_Op<"type_array_attr_with_default"> {
   let arguments = (ins DefaultValuedAttr<TypeArrayAttr, "{}">:$attr);

 }
 
 //===----------------------------------------------------------------------===//
 // Test Attribute Constraints
 //===----------------------------------------------------------------------===//
 
 def SymbolRefOp : TEST_Op<"symbol_ref_attr"> {
   let arguments = (ins
-    Confined<FlatSymbolRefAttr, [ReferToOp<"func::FuncOp">]>:$symbol
+    ConfinedAttr<FlatSymbolRefAttr, [ReferToOp<"func::FuncOp">]>:$symbol
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Test Regions
 //===----------------------------------------------------------------------===//
 
 def OneRegionOp : TEST_Op<"one_region_op", []> {
def OpNativeCodeCall7 : TEST_Op<"native_code_call7"> {
   let arguments = (ins I32:$input);
   let results = (outs I32);
 }
 def BindMultipleNativeCodeCallResult : NativeCodeCall<"bindMultipleNativeCodeCallResult($0, $1)", 2>;
 def : Pattern<(OpNativeCodeCall6 $arg1, $arg2),
               [(OpNativeCodeCall7 (BindMultipleNativeCodeCallResult:$native__0 $arg1, $arg2)),
                (OpNativeCodeCall7 $native__1)]>;
 
-// Test AllAttrConstraintsOf.
+// Test AllAttrOf.
 def OpAllAttrConstraint1 : TEST_Op<"all_attr_constraint_of1"> {
   let arguments = (ins I64ArrayAttr:$attr);
   let results = (outs I32);
 }
 def OpAllAttrConstraint2 : TEST_Op<"all_attr_constraint_of2"> {
   let arguments = (ins I64ArrayAttr:$attr);
   let results = (outs I32);
 }
 def Constraint0 : AttrConstraint<
     CPred<"$_self.cast<ArrayAttr>()[0]."
           "cast<::mlir::IntegerAttr>().getInt() == 0">,
     "[0] == 0">;
 def Constraint1 : AttrConstraint<
     CPred<"$_self.cast<ArrayAttr>()[1].cast<::mlir::IntegerAttr>().getInt() == 1">,
     "[1] == 1">;
 def : Pat<(OpAllAttrConstraint1
-            AllAttrConstraintsOf<[Constraint0, Constraint1]>:$attr),
+            AllAttrOf<[Constraint0, Constraint1]>:$attr),
           (OpAllAttrConstraint2 $attr)>;
 
 // Op for testing RewritePattern removing op with inner ops.
 def TestOpWithRegionPattern : TEST_Op<"op_with_region_pattern"> {
   let regions = (region SizedRegion<1>:$region);
   let hasCanonicalizer = 1;
 }
 

mlir/test/mlir-pdll/Parser/include/ops.td

 include "include/interfaces.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
 
 def OpAllEmpty : Op<Test_Dialect, "all_empty">;
 
 def OpAllSingle : Op<Test_Dialect, "all_single"> {
   let arguments = (ins
     I64:$operand,
     I64Attr:$attr,
-    Confined<I64Attr, [IntNonNegative]>:$nonNegativeAttr
+    ConfinedAttr<I64Attr, [IntNonNegative]>:$nonNegativeAttr
   );
   let results = (outs I64:$result);
 }
 
 def OpAllOptional : Op<Test_Dialect, "all_optional"> {
   let arguments = (ins Optional<I64>:$operand, OptionalAttr<I64Attr>:$attr);
   let results = (outs Optional<I64>:$result);
 }

mlir/test/mlir-tblgen/predicate.td

def OpB : NS_Op<"op_for_And_PredOpTrait", [
     PredOpTrait<"both first and second holds",
                 And<[CPred<"first">, CPred<"second">]>>]> {
 }
 
 // CHECK-LABEL: OpB::verify
 // CHECK: if (!(((first)) && ((second))))
 
 def OpF : NS_Op<"op_for_int_min_val", []> {
-  let arguments = (ins Confined<I32Attr, [IntMinValue<10>]>:$attr);
+  let arguments = (ins ConfinedAttr<I32Attr, [IntMinValue<10>]>:$attr);
 }
 
 // CHECK-LABEL: OpFAdaptor::verify
 // CHECK:       (tblgen_attr.cast<::mlir::IntegerAttr>().getInt() >= 10)
 // CHECK-NEXT:  "attribute 'attr' failed to satisfy constraint: 32-bit signless integer attribute whose minimum value is 10"
 
 def OpFX : NS_Op<"op_for_int_max_val", []> {
-  let arguments = (ins Confined<I32Attr, [IntMaxValue<10>]>:$attr);
+  let arguments = (ins ConfinedAttr<I32Attr, [IntMaxValue<10>]>:$attr);
 }
 
 // CHECK-LABEL: OpFXAdaptor::verify
 // CHECK:       (tblgen_attr.cast<::mlir::IntegerAttr>().getInt() <= 10)
 // CHECK-NEXT:  "attribute 'attr' failed to satisfy constraint: 32-bit signless integer attribute whose maximum value is 10"
 
 def OpG : NS_Op<"op_for_arr_min_count", []> {
-  let arguments = (ins Confined<ArrayAttr, [ArrayMinCount<8>]>:$attr);
+  let arguments = (ins ConfinedAttr<ArrayAttr, [ArrayMinCount<8>]>:$attr);
 }
 
 // CHECK-LABEL: OpGAdaptor::verify
 // CHECK:       (tblgen_attr.cast<::mlir::ArrayAttr>().size() >= 8)
 // CHECK-NEXT:  "attribute 'attr' failed to satisfy constraint: array attribute with at least 8 elements"
 
 def OpH : NS_Op<"op_for_arr_value_at_index", []> {
-  let arguments = (ins Confined<ArrayAttr, [IntArrayNthElemEq<0, 8>]>:$attr);
+  let arguments = (ins ConfinedAttr<ArrayAttr, [IntArrayNthElemEq<0, 8>]>:$attr);
 }
 
 // CHECK-LABEL: OpHAdaptor::verify
 // CHECK: (((tblgen_attr.cast<::mlir::ArrayAttr>().size() > 0)) && ((tblgen_attr.cast<::mlir::ArrayAttr>()[0].cast<::mlir::IntegerAttr>().getInt() == 8)))))
 // CHECK-NEXT:  "attribute 'attr' failed to satisfy constraint: array attribute whose 0-th element must be 8"
 
 def OpI: NS_Op<"op_for_arr_min_value_at_index", []> {
-  let arguments = (ins Confined<ArrayAttr, [IntArrayNthElemMinValue<0, 8>]>:$attr);
+  let arguments = (ins ConfinedAttr<ArrayAttr, [IntArrayNthElemMinValue<0, 8>]>:$attr);
 }
 
 // CHECK-LABEL: OpIAdaptor::verify
 // CHECK: (((tblgen_attr.cast<::mlir::ArrayAttr>().size() > 0)) && ((tblgen_attr.cast<::mlir::ArrayAttr>()[0].cast<::mlir::IntegerAttr>().getInt() >= 8)))))
 // CHECK-NEXT: "attribute 'attr' failed to satisfy constraint: array attribute whose 0-th element must be at least 8"
 
 def OpJ: NS_Op<"op_for_TCopVTEtAreSameAt", [
                 PredOpTrait<"operands indexed at 0, 2, 3 should all have "