NFC: Cleanup test ops and traits tests

1. Rename a few ops to make it clear they operate on *element* types.
2. Remove unused and generic operand and result ODS names (e.g. $res, $arg, $input). These are just clutter and don't make the op definitions any clearer.
3. Give test cases with duplicate names clearer names.
4. Add missing test case for no operands in SameOperandAndResultElementType.

PiperOrigin-RevId: 273067933

1 files changed, 61 insertions, 61 deletions

diff --git a/mlir/test/lib/TestDialect/TestOps.td b/mlir/test/lib/TestDialect/TestOps.td
index 41e44f69c2f..a7c5fa05235 100644
--- a/mlir/test/lib/TestDialect/TestOps.td
+++ b/mlir/test/lib/TestDialect/TestOps.td
@@ -234,27 +234,27 @@ def FunctionalRegionOp : TEST_Op<"functional_region_op",
 // Test Traits
 //===----------------------------------------------------------------------===//
 
-def SameOperandElementTypeOp : TEST_Op<"same_operand_type",
+def SameOperandElementTypeOp : TEST_Op<"same_operand_element_type",
     [SameOperandsElementType]> {
-  let arguments = (ins AnyVectorOrTensor:$x, AnyVectorOrTensor:$y);
-  let results = (outs AnyVectorOrTensor:$res);
+  let arguments = (ins AnyVectorOrTensor, AnyVectorOrTensor);
+  let results = (outs AnyVectorOrTensor);
 }
 
-def SameOperandAndResultElementTypeOp : TEST_Op<"same_operand_and_result_type",
+def SameOperandAndResultElementTypeOp : TEST_Op<"same_operand_and_result_element_type",
     [SameOperandsAndResultElementType]> {
-  let arguments = (ins Variadic<AnyVectorOrTensor>:$args);
-  let results = (outs Variadic<AnyVectorOrTensor>:$res);
+  let arguments = (ins Variadic<AnyVectorOrTensor>);
+  let results = (outs Variadic<AnyVectorOrTensor>);
 }
 
 def SameOperandShapeOp : TEST_Op<"same_operand_shape", [SameOperandsShape]> {
-  let arguments = (ins Variadic<AnyVectorOrTensor>:$args);
-  let results = (outs AnyVectorOrTensor:$res);
+  let arguments = (ins Variadic<AnyVectorOrTensor>);
+  let results = (outs AnyVectorOrTensor);
 }
 
 def SameOperandAndResultShapeOp : TEST_Op<"same_operand_and_result_shape",
     [SameOperandsAndResultShape]> {
-  let arguments = (ins Variadic<AnyVectorOrTensor>:$args);
-  let results = (outs Variadic<AnyVectorOrTensor>:$res);
+  let arguments = (ins Variadic<AnyVectorOrTensor>);
+  let results = (outs Variadic<AnyVectorOrTensor>);
 }
 
 def ArgAndResHaveFixedElementTypesOp :
@@ -333,8 +333,8 @@ def IfFirstOperandIsNoneThenSoIsSecond :
 }
 
 def BroadcastableOp : TEST_Op<"broadcastable", [Broadcastable]> {
-  let arguments = (ins AnyTensor:$x, AnyTensor:$y);
-  let results = (outs AnyTensor:$res);
+  let arguments = (ins AnyTensor, AnyTensor);
+  let results = (outs AnyTensor);
 }
 
 // There the "HasParent" trait.
@@ -354,8 +354,8 @@ def I32ElementsAttrOp : TEST_Op<"i32ElementsAttr"> {
 
 def OpWithInferTypeInterfaceOp : TEST_Op<"op_with_infer_type_if",
     [DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
-  let arguments = (ins AnyTensor:$x, AnyTensor:$y);
-  let results = (outs AnyTensor:$res);
+  let arguments = (ins AnyTensor, AnyTensor);
+  let results = (outs AnyTensor);
 }
 
 def IsNotScalar : Constraint<CPred<"$0.getType().getRank() != 0">>;
@@ -369,13 +369,13 @@ def UpdateAttr : Pat<(I32ElementsAttrOp $attr),
 //===----------------------------------------------------------------------===//
 
 def OpA : TEST_Op<"op_a"> {
-  let arguments = (ins I32:$operand, I32Attr:$attr);
-  let results = (outs I32:$result);
+  let arguments = (ins I32, I32Attr:$attr);
+  let results = (outs I32);
 }
 
 def OpB : TEST_Op<"op_b"> {
-  let arguments = (ins I32:$operand, I32Attr:$attr);
-  let results = (outs I32:$result);
+  let arguments = (ins I32, I32Attr:$attr);
+  let results = (outs I32);
 }
 
 // Test named pattern.
@@ -385,10 +385,10 @@ def TestNamedPatternRule : Pat<(OpA $input, $attr), (OpB $input, $attr)>;
 def : Pat<(OpA (OpA $input, $attr), $bttr), (OpB $input, $bttr)>;
 
 // Test added benefit.
-def OpD : TEST_Op<"op_d">, Arguments<(ins I32:$arg)>, Results<(outs I32:$res)>;
-def OpE : TEST_Op<"op_e">, Arguments<(ins I32:$arg)>, Results<(outs I32:$res)>;
-def OpF : TEST_Op<"op_f">, Arguments<(ins I32:$arg)>, Results<(outs I32:$res)>;
-def OpG : TEST_Op<"op_g">, Arguments<(ins I32:$arg)>, Results<(outs I32:$res)>;
+def OpD : TEST_Op<"op_d">, Arguments<(ins I32)>, Results<(outs I32)>;
+def OpE : TEST_Op<"op_e">, Arguments<(ins I32)>, Results<(outs I32)>;
+def OpF : TEST_Op<"op_f">, Arguments<(ins I32)>, Results<(outs I32)>;
+def OpG : TEST_Op<"op_g">, Arguments<(ins I32)>, Results<(outs I32)>;
 // Verify that bumping benefit results in selecting different op.
 def : Pat<(OpD $input), (OpE $input)>;
 def : Pat<(OpD $input), (OpF $input), [], (addBenefit 10)>;
@@ -397,13 +397,13 @@ def : Pat<(OpG $input), (OpB $input, ConstantAttr<I32Attr, "20">:$attr)>;
 def : Pat<(OpG (OpG $input)), (OpB $input, ConstantAttr<I32Attr, "34">:$attr)>;
 
 // Test patterns for zero-result op.
-def OpH : TEST_Op<"op_h">, Arguments<(ins I32:$arg)>, Results<(outs)>;
-def OpI : TEST_Op<"op_i">, Arguments<(ins I32:$arg)>, Results<(outs)>;
+def OpH : TEST_Op<"op_h">, Arguments<(ins I32)>, Results<(outs)>;
+def OpI : TEST_Op<"op_i">, Arguments<(ins I32)>, Results<(outs)>;
 def : Pat<(OpH $input), (OpI $input)>;
 
 // Test patterns for zero-input op.
-def OpJ : TEST_Op<"op_j">, Arguments<(ins)>, Results<(outs I32:$res)>;
-def OpK : TEST_Op<"op_k">, Arguments<(ins)>, Results<(outs I32:$res)>;
+def OpJ : TEST_Op<"op_j">, Arguments<(ins)>, Results<(outs I32)>;
+def OpK : TEST_Op<"op_k">, Arguments<(ins)>, Results<(outs I32)>;
 def : Pat<(OpJ), (OpK)>;
 
 // Test NativeCodeCall.
@@ -413,11 +413,11 @@ def OpNativeCodeCall1 : TEST_Op<"native_code_call1"> {
     BoolAttr:$choice,
     I64Attr:$attr1, I64Attr:$attr2
   );
-  let results = (outs I32:$output);
+  let results = (outs I32);
 }
 def OpNativeCodeCall2 : TEST_Op<"native_code_call2"> {
   let arguments = (ins I32:$input, I64ArrayAttr:$attr);
-  let results = (outs I32:$output);
+  let results = (outs I32);
 }
 // Native code call to invoke a C++ function
 def CreateOperand: NativeCodeCall<"chooseOperand($0, $1, $2)">;
@@ -441,11 +441,11 @@ def : Pat<(OpNativeCodeCall1 $input1, $input2,
 // Test AllAttrConstraintsOf.
 def OpAllAttrConstraint1 : TEST_Op<"all_attr_constraint_of1"> {
   let arguments = (ins I64ArrayAttr:$attr);
-  let results = (outs I32:$output);
+  let results = (outs I32);
 }
 def OpAllAttrConstraint2 : TEST_Op<"all_attr_constraint_of2"> {
   let arguments = (ins I64ArrayAttr:$attr);
-  let results = (outs I32:$output);
+  let results = (outs I32);
 }
 def Constraint0 : AttrConstraint<
     CPred<"$_self.cast<ArrayAttr>().getValue()[0]."
@@ -474,7 +474,7 @@ def TestOpWithRegionFoldNoSideEffect : TEST_Op<
 // Op for testing folding of outer op with inner ops.
 def TestOpWithRegionFold : TEST_Op<"op_with_region_fold"> {
   let arguments = (ins I32:$operand);
-  let results = (outs I32:$result);
+  let results = (outs I32);
   let regions = (region SizedRegion<1>:$region);
   let hasFolder = 1;
 }
@@ -485,11 +485,11 @@ def TestOpWithRegionFold : TEST_Op<"op_with_region_fold"> {
 // Test symbol binding.
 def OpSymbolBindingA : TEST_Op<"symbol_binding_a", []> {
   let arguments = (ins I32:$operand, I64Attr:$attr);
-  let results = (outs I32:$result);
+  let results = (outs I32);
 }
 def OpSymbolBindingB : TEST_Op<"symbol_binding_b", []> {
   let arguments = (ins I32:$operand);
-  let results = (outs I32:$result);
+  let results = (outs I32);
 
   let builders = [
     OpBuilder<
@@ -502,12 +502,12 @@ def OpSymbolBindingB : TEST_Op<"symbol_binding_b", []> {
 }
 def OpSymbolBindingC : TEST_Op<"symbol_binding_c", []> {
   let arguments = (ins I32:$operand);
-  let results = (outs I32:$result);
+  let results = (outs I32);
   let builders = OpSymbolBindingB.builders;
 }
 def OpSymbolBindingD : TEST_Op<"symbol_binding_d", []> {
   let arguments = (ins I32:$input1, I32:$input2, I64Attr:$attr);
-  let results = (outs I32:$result);
+  let results = (outs I32);
 }
 def HasOneUse: Constraint<CPred<"$0->hasOneUse()">, "has one use">;
 def : Pattern<
@@ -532,11 +532,11 @@ def OpAttrMatch1 : TEST_Op<"match_op_attribute1"> {
     DefaultValuedAttr<I32Attr, "42">:$default_valued_attr,
     I32Attr:$more_attr
   );
-  let results = (outs I32:$output);
+  let results = (outs I32);
 }
 def OpAttrMatch2 : TEST_Op<"match_op_attribute2"> {
   let arguments = OpAttrMatch1.arguments;
-  let results = (outs I32:$output);
+  let results = (outs I32);
 }
 def MoreConstraint : AttrConstraint<
     CPred<"$_self.cast<IntegerAttr>().getInt() == 4">, "more constraint">;
@@ -556,7 +556,7 @@ def OpAttrMatch4 : TEST_Op<"match_op_attribute4"> {
 def : Pat<(OpAttrMatch3 $attr), (OpAttrMatch4 ConstUnitAttr, $attr)>;
 
 // Test with constant attr.
-def OpC : TEST_Op<"op_c">, Arguments<(ins I32:$arg)>, Results<(outs I32:$res)>;
+def OpC : TEST_Op<"op_c">, Arguments<(ins I32)>, Results<(outs I32)>;
 def : Pat<(OpC $input), (OpB $input, ConstantAttr<I32Attr, "17">:$attr)>;
 
 // Test string enum attribute in rewrites.
@@ -623,7 +623,7 @@ def OneResultOp2 : TEST_Op<"one_result2"> {
 }
 
 def OneResultOp3 : TEST_Op<"one_result3"> {
-  let arguments = (ins F32:$input);
+  let arguments = (ins F32);
   let results = (outs I32:$result1);
 }
 
@@ -667,12 +667,12 @@ def : Pattern<
 // Test Patterns (Variadic Ops)
 
 def OneVResOneVOperandOp1 : TEST_Op<"one_variadic_out_one_variadic_in1"> {
-  let arguments = (ins Variadic<I32>:$inputs);
-  let results = (outs Variadic<I32>:$outputs);
+  let arguments = (ins Variadic<I32>);
+  let results = (outs Variadic<I32>);
 }
 def OneVResOneVOperandOp2 : TEST_Op<"one_variadic_out_one_variadic_in2"> {
-  let arguments = (ins Variadic<I32>:$inputs);
-  let results = (outs Variadic<I32>:$outputs);
+  let arguments = (ins Variadic<I32>);
+  let results = (outs Variadic<I32>);
 }
 
 // Rewrite an op with one variadic operand and one variadic result to
@@ -724,7 +724,7 @@ def MixedVResultOp2 : TEST_Op<"mixed_variadic_out2", [SameVariadicResultSize]> {
 def : Pat<(MixedVResultOp1), (MixedVResultOp2)>;
 
 def OneI32ResultOp : TEST_Op<"one_i32_out"> {
-  let results = (outs I32:$output);
+  let results = (outs I32);
 }
 
 def MixedVOperandOp3 : TEST_Op<"mixed_variadic_in3",
@@ -736,7 +736,7 @@ def MixedVOperandOp3 : TEST_Op<"mixed_variadic_in3",
     I32Attr:$count
   );
 
-  let results = (outs I32:$output);
+  let results = (outs I32);
 }
 
 def MixedVResultOp3 : TEST_Op<"mixed_variadic_out3",
@@ -783,14 +783,14 @@ def Test_LegalizerEnum_Failure : StrEnumAttrCase<"Failure">;
 def Test_LegalizerEnum : StrEnumAttr<"Success", "Failure",
   [Test_LegalizerEnum_Success, Test_LegalizerEnum_Failure]>;
 
-def ILLegalOpA : TEST_Op<"illegal_op_a">, Results<(outs I32:$res)>;
-def ILLegalOpB : TEST_Op<"illegal_op_b">, Results<(outs I32:$res)>;
-def ILLegalOpC : TEST_Op<"illegal_op_c">, Results<(outs I32:$res)>;
-def ILLegalOpD : TEST_Op<"illegal_op_d">, Results<(outs I32:$res)>;
-def ILLegalOpE : TEST_Op<"illegal_op_e">, Results<(outs I32:$res)>;
-def ILLegalOpF : TEST_Op<"illegal_op_f">, Results<(outs I32:$res)>;
+def ILLegalOpA : TEST_Op<"illegal_op_a">, Results<(outs I32)>;
+def ILLegalOpB : TEST_Op<"illegal_op_b">, Results<(outs I32)>;
+def ILLegalOpC : TEST_Op<"illegal_op_c">, Results<(outs I32)>;
+def ILLegalOpD : TEST_Op<"illegal_op_d">, Results<(outs I32)>;
+def ILLegalOpE : TEST_Op<"illegal_op_e">, Results<(outs I32)>;
+def ILLegalOpF : TEST_Op<"illegal_op_f">, Results<(outs I32)>;
 def LegalOpA : TEST_Op<"legal_op_a">,
-  Arguments<(ins Test_LegalizerEnum:$status)>, Results<(outs I32:$res)>;
+  Arguments<(ins Test_LegalizerEnum:$status)>, Results<(outs I32)>;
 
 // Check that smaller pattern depths are chosen, i.e. prioritize more direct
 // mappings.
@@ -809,7 +809,7 @@ def : Pat<(ILLegalOpE), (LegalOpA Test_LegalizerEnum_Success)>;
 
 // Check that patterns use the most up-to-date value when being replaced.
 def TestRewriteOp : TEST_Op<"rewrite">,
-  Arguments<(ins AnyType:$input)>, Results<(outs AnyType:$res)>;
+  Arguments<(ins AnyType)>, Results<(outs AnyType)>;
 def : Pat<(TestRewriteOp $input), (replaceWithValue $input)>;
 
 //===----------------------------------------------------------------------===//
@@ -818,17 +818,17 @@ def : Pat<(TestRewriteOp $input), (replaceWithValue $input)>;
 
 def TestRegionBuilderOp : TEST_Op<"region_builder">;
 def TestReturnOp : TEST_Op<"return", [Terminator]>,
-  Arguments<(ins Variadic<AnyType>:$inputs)>;
+  Arguments<(ins Variadic<AnyType>)>;
 def TestCastOp : TEST_Op<"cast">,
-  Arguments<(ins Variadic<AnyType>:$inputs)>, Results<(outs AnyType:$res)>;
+  Arguments<(ins Variadic<AnyType>)>, Results<(outs AnyType)>;
 def TestInvalidOp : TEST_Op<"invalid", [Terminator]>,
-  Arguments<(ins Variadic<AnyType>:$inputs)>;
+  Arguments<(ins Variadic<AnyType>)>;
 def TestTypeProducerOp : TEST_Op<"type_producer">,
-  Results<(outs AnyType:$output)>;
+  Results<(outs AnyType)>;
 def TestTypeConsumerOp : TEST_Op<"type_consumer">,
-  Arguments<(ins AnyType:$input)>;
+  Arguments<(ins AnyType)>;
 def TestValidOp : TEST_Op<"valid", [Terminator]>,
-  Arguments<(ins Variadic<AnyType>:$inputs)>;
+  Arguments<(ins Variadic<AnyType>)>;
 
 //===----------------------------------------------------------------------===//
 // Test parser.
@@ -850,7 +850,7 @@ def IsolatedRegionOp : TEST_Op<"isolated_region", [IsolatedFromAbove]> {
     argument is of index type.
   }];
 
-  let arguments = (ins Index:$input);
+  let arguments = (ins Index);
   let regions = (region SizedRegion<1>:$region);
   let parser = [{ return ::parse$cppClass(parser, result); }];
   let printer = [{ return ::print(p, *this); }];
@@ -864,7 +864,7 @@ def WrappingRegionOp : TEST_Op<"wrapping_region",
     parseGenericOperation from the custom parser.
   }];
 
-  let results = (outs Variadic<AnyType>:$outputs);
+  let results = (outs Variadic<AnyType>);
   let regions = (region SizedRegion<1>:$region);
   let parser = [{ return ::parse$cppClass(parser, result); }];
   let printer = [{ return ::print(p, *this); }];