[mlir][irdl] Introduce names in IRDL value lists (llvm#123525)

In order to meaningfully generate getters and setters from IRDL, it
makes sense to embed the names of operands, results, etc. in the IR
definition. This PR introduces this feature. Names are constrained
similarly to TableGen names.

Author: Moxinilian

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

@@ -20,6 +20,7 @@ include "IRDLInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/IR/SymbolInterfaces.td"
+include "mlir/IR/BuiltinAttributes.td"
 
 class IRDL_Op<string mnemonic, list<Trait> traits = []>
     : Op<IRDL_Dialect, mnemonic, traits>;
@@ -133,7 +134,7 @@ def IRDL_ParametersOp : IRDL_Op<"parameters",
     "Define the constraints on parameters of a type/attribute definition";
   let description = [{
     `irdl.parameters` defines the constraints on parameters of a type or
-    attribute definition.
+    attribute definition. Each parameter is named after an identifier.
 
     Example:
 
@@ -143,17 +144,19 @@ def IRDL_ParametersOp : IRDL_Op<"parameters",
         %0 = irdl.is i32
         %1 = irdl.is i64
         %2 = irdl.any_of(%0, %1)
-        irdl.parameters(%2)
+        irdl.parameters(elem: %2)
       }
     }
     ```
 
     The above program defines a type `complex` inside the dialect `cmath`. The
-    type has a single parameter that should be either `i32` or `i64`.
+    type has a single parameter `elem` that should be either `i32` or `i64`.
   }];
 
-  let arguments = (ins Variadic<IRDL_AttributeType>:$args);
-  let assemblyFormat = " `(` $args `)` attr-dict ";
+  let arguments = (ins Variadic<IRDL_AttributeType>:$args,
+                        StrArrayAttr:$names);
+  let assemblyFormat = " `` custom<NamedValueList>($args, $names) attr-dict ";
+  let hasVerifier = true;
 }
 
 //===----------------------------------------------------------------------===//
@@ -198,16 +201,17 @@ def IRDL_OperationOp : IRDL_Op<"operation",
   let regions = (region SizedRegion<1>:$body);
   let assemblyFormat =
     "$sym_name attr-dict-with-keyword custom<SingleBlockRegion>($body)";
+  let hasRegionVerifier = true;
 }
 
 def IRDL_OperandsOp : IRDL_Op<"operands", [HasParent<"OperationOp">]> {
   let summary = "Define the operands of an operation";
   let description = [{
     `irdl.operands` define the operands of the `irdl.operation` parent operation
-    definition.
+    definition. Each operand is named after an identifier.
 
     In the following example, `irdl.operands` defines the operands of the
-    `norm` operation:
+    `mul` operation:
 
     ```mlir
     irdl.dialect @cmath {
@@ -217,8 +221,8 @@ def IRDL_OperandsOp : IRDL_Op<"operands", [HasParent<"OperationOp">]> {
       irdl.operation @mul {
         %0 = irdl.any
         %1 = irdl.parametric @cmath::@complex<%0>
-        irdl.results(%1)
-        irdl.operands(%1, %1)
+        irdl.results(res: %1)
+        irdl.operands(lhs: %1, rhs: %1)
       }
     }
     ```
@@ -228,43 +232,45 @@ def IRDL_OperandsOp : IRDL_Op<"operands", [HasParent<"OperationOp">]> {
 
     The operands can also be marked as variadic or optional:
     ```mlir
-    irdl.operands(%0, single %1, optional %2, variadic %3)
+    irdl.operands(foo: %0, bar: single %1, baz: optional %2, qux: variadic %3)
     ```
 
-    Here, %0 and %1 are required single operands, %2 is an optional operand,
-    and %3 is a variadic operand.
+    Here, foo and bar are required single operands, baz is an optional operand,
+    and qux is a variadic operand.
 
     When more than one operand is marked as optional or variadic, the operation
     will expect a 'operandSegmentSizes' attribute that defines the number of
     operands in each segment.
   }];
 
   let arguments = (ins Variadic<IRDL_AttributeType>:$args,
-                        VariadicityArrayAttr:$variadicity);
+                       StrArrayAttr:$names,
+                       VariadicityArrayAttr:$variadicity);
   let assemblyFormat =
-    "`` custom<ValuesWithVariadicity>($args, $variadicity) attr-dict";
+    " `` custom<NamedValueListWithVariadicity>($args, $names, $variadicity) attr-dict";
   let hasVerifier = true;
 }
 
 def IRDL_ResultsOp : IRDL_Op<"results", [HasParent<"OperationOp">]> {
   let summary = "Define the results of an operation";
   let description = [{
     `irdl.results` define the results of the `irdl.operation` parent operation
-    definition.
+    definition. Each result is named after an identifier.
 
     In the following example, `irdl.results` defines the results of the
-    `norm` operation:
+    `get_values` operation:
 
     ```mlir
     irdl.dialect @cmath {
 
       irdl.type @complex { /* ... */ }
 
+      /// Returns the real and imaginary parts of a complex number.
       irdl.operation @get_values {
         %0 = irdl.any
         %1 = irdl.parametric @cmath::@complex<%0>
-        irdl.results(%0, %0)
-        irdl.operands(%1)
+        irdl.results(re: %0, im: %0)
+        irdl.operands(complex: %1)
       }
     }
     ```
@@ -274,21 +280,22 @@ def IRDL_ResultsOp : IRDL_Op<"results", [HasParent<"OperationOp">]> {
 
     The results can also be marked as variadic or optional:
     ```mlir
-    irdl.results(%0, single %1, optional %2, variadic %3)
+    irdl.results(foo: %0, bar: single %1, baz: optional %2, qux: variadic %3)
     ```
 
-    Here, %0 and %1 are required single results, %2 is an optional result,
-    and %3 is a variadic result.
+    Here, foo and bar are required single results, baz is an optional result,
+    and qux is a variadic result.
 
     When more than one result is marked as optional or variadic, the operation
     will expect a 'resultSegmentSizes' attribute that defines the number of
     results in each segment.
   }];
 
   let arguments = (ins Variadic<IRDL_AttributeType>:$args,
+                        StrArrayAttr:$names,
                         VariadicityArrayAttr:$variadicity);
   let assemblyFormat =
-    " `` custom<ValuesWithVariadicity>($args, $variadicity) attr-dict";
+    " `` custom<NamedValueListWithVariadicity>($args, $names, $variadicity) attr-dict";
   let hasVerifier = true;
 }
 
@@ -335,7 +342,8 @@ def IRDL_RegionOp : IRDL_Op<"region",
   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.
+    that a region of an operation should satify. Each region is named after
+    an identifier.
 
     These characteristics include constraints for the entry block arguments
     of the region and the total number of blocks it contains.
@@ -360,19 +368,19 @@ def IRDL_RegionOp : IRDL_Op<"region",
           %r2 = irdl.region(%v0, %v1)
           %r3 = irdl.region with size 3
 
-          irdl.regions(%r0, %r1, %r2, %r3)
+          irdl.regions(foo: %r0, bar: %r1, baz: %r2, qux: %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
+    * Region `foo` 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.
+    * Region `bar` should have an empty set of arguments.
+    * Region `baz` should have two arguments of types `i32` and `i64`.
+    * Region `qux` should contain exactly three blocks.
   }];
   let arguments = (ins Variadic<IRDL_AttributeType>:$entryBlockArgs,
                     OptionalAttr<I32Attr>:$numberOfBlocks,
@@ -391,7 +399,8 @@ 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.
+    values produced by `irdl.region` operation as arguments. Each
+    region has an identifier as name.
 
     Example:
 
@@ -401,18 +410,19 @@ def IRDL_RegionsOp : IRDL_Op<"regions", [HasParent<"OperationOp">]> {
         %r1 = irdl.region with size 3
         %0 = irdl.any
         %r2 = irdl.region(%0)
-        irdl.regions(%r1, %r2)
+        irdl.regions(foo: %r1, bar: %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.
+    The first region (`foo`) should contain three blocks.
+    The second region (`bar`) should have one region with one argument.
   }];
 
-  let arguments = (ins Variadic<IRDL_RegionType>:$args);
-  let assemblyFormat = " `(` $args `)` attr-dict ";
+  let arguments = (ins Variadic<IRDL_RegionType>:$args, StrArrayAttr:$names);
+  let assemblyFormat = " `` custom<NamedValueList>($args, $names) attr-dict ";
+  let hasVerifier = true;
 }
 
 //===----------------------------------------------------------------------===//