[mlir][linalg][transform][python] Fix optional args of PadOp mix-in.

[ingomueller-net]

Summary

The mix-in did not allow to *not* set many of the arguments, even though
they represent optional attributes. Instead, it set default values,
which have different semantics in some cases. In other cases, setting
the default values is already done by the C++ layer, in which case they
are currently redundant and may be wrong in some potential future change
in the TD or C++ files. With this patch, None is preserved until the
generated binding, which handles them as desired.

[ingomueller-net]

• Fix type hints.
• Add test for StringAttr padding value.

[ingomueller-net]

Could somebody look at this patch?

[springerm]

mlir/test/python/dialects/transform_structured_ext.py

343

Is this silently getting dropped?

mlir/python/mlir/dialects/_structured_transform_ops_ext.py

 def _get_value_list(
     sequence_or_array_attr: Union[Sequence[any], ArrayAttr]
 ) -> Sequence[any]:
     return [_get_value_or_attribute_value(v) for v in sequence_or_array_attr]
 
 
 def _get_int_array_attr(values: Optional[Union[ArrayAttr, IntOrAttrList]]) -> ArrayAttr:
     if values is None:
-        return ArrayAttr.get([])
+        return None
 
     # Turn into a Python list of Python ints.
     values = _get_value_list(values)
 
     # Make an ArrayAttr of IntegerAttrs out of it.
     return ArrayAttr.get(
         [IntegerAttr.get(IntegerType.get_signless(64), v) for v in values]
     )
 
 
 def _get_int_array_array_attr(
     values: Optional[Union[ArrayAttr, Sequence[Union[ArrayAttr, IntOrAttrList]]]]
 ) -> ArrayAttr:
     """Creates an ArrayAttr of ArrayAttrs of IntegerAttrs.
 
     The input has to be a collection of collection of integers, where any
     Python Sequence and ArrayAttr are admissible collections and Python ints and
     any IntegerAttr are admissible integers. Both levels of collections are
     turned into ArrayAttr; the inner level is turned into IntegerAttrs of i64s.
     If the input is None, an empty ArrayAttr is returned.
     """
     if values is None:
-        return ArrayAttr.get([])
+        return None
 
     # Make sure the outer level is a list.
     values = _get_value_list(values)
 
     # The inner level is now either invalid or a mixed sequence of ArrayAttrs and
     # Sequences. Make sure the nested values are all lists.
     values = [_get_value_list(nested) for nested in values]
 

 
 class PadOp:
     """Specialization for PadOp class."""
 
     def __init__(
         self,
         target: Union[Operation, OpView, Value],
         *,
-        padding_values: Optional[
-            Union[ArrayAttr, Sequence[Union[bool, int, float, Attribute]]]
-        ] = None,
+        padding_values: Optional[Union[ArrayAttr, Sequence[Attribute]]] = None,
         padding_dimensions: OptionalIntList = None,
         pad_to_multiple_of: OptionalIntList = None,
         pack_paddings: OptionalIntList = None,
         transpose_paddings: Optional[
             Union[ArrayAttr, Sequence[Union[ArrayAttr, IntOrAttrList]]]
         ] = None,
         copy_back_op: Optional[Union[str, StringAttr]] = None,
         loc=None,
         ip=None,
     ):
-        if padding_values is None:
-            padding_values = []
-        if padding_dimensions is None:
-            padding_dimensions = []
-        if pad_to_multiple_of is None:
-            pad_to_multiple_of = []
-        if pack_paddings is None:
-            pack_paddings = []
-        if transpose_paddings is None:
-            transpose_paddings = []
-
         padding_dimensions = _get_int_array_attr(padding_dimensions)
         pad_to_multiple_of = _get_int_array_attr(pad_to_multiple_of)
         pack_paddings = _get_int_array_attr(pack_paddings)
         transpose_paddings = _get_int_array_array_attr(transpose_paddings)
 
         pdl_operation_type = pdl.OperationType.get()
         super().__init__(
             pdl_operation_type,

mlir/test/python/dialects/transform_structured_ext.py

def testMultitileSizes():
     # CHECK-LABEL: TEST: testMultitileSizes
     # CHECK: transform.sequence
     # CHECK: transform.structured.multitile_sizes
     # CHECK-DAG: dimension = 1
     # CHECK-DAG: target_size = 42
 
 
 @run
-def testPad():
+def testPadOpNoArgs():
+    sequence = transform.SequenceOp(
+        transform.FailurePropagationMode.Propagate, [], pdl.OperationType.get()
+    )
+    with InsertionPoint(sequence.body):
+        structured.PadOp(sequence.bodyTarget)
+        transform.YieldOp()
+    # CHECK-LABEL: TEST: testPadOpNoArgs
+    # CHECK: transform.sequence
+    # CHECK: transform.structured.pad
+    # CHECK-NOT: copy_back_op
+    # CHECK-NOT: pack_paddings
+    # CHECK-NOT: pad_to_multiple_of
+    # CHECK-NOT: padding_dimensions
+    # CHECK-NOT: padding_values
+    # CHECK-NOT: transpose_paddings
+
+
+@run
+def testPadOpArgs():
     sequence = transform.SequenceOp(
         transform.FailurePropagationMode.Propagate, [], pdl.OperationType.get()
     )
     with InsertionPoint(sequence.body):
         structured.PadOp(
             sequence.bodyTarget,
-            padding_values=[FloatAttr.get_f32(42.0)],
+            padding_values=[FloatAttr.get_f32(42.0), StringAttr.get("0")],
             padding_dimensions=Attribute.parse("[1]"),
             pad_to_multiple_of=[128],
             pack_paddings=[0],
             transpose_paddings=[[1, Attribute.parse("0")], Attribute.parse("[0, 1]")],
             copy_back_op="linalg.copy",
         )
         transform.YieldOp()
-    # CHECK-LABEL: TEST: testPad
+    # CHECK-LABEL: TEST: testPadOpArgs
     # CHECK: transform.sequence
     # CHECK: transform.structured.pad
     # CHECK-DAG: copy_back_op = "linalg.copy"
     # CHECK-DAG: pack_paddings = [0]
     # CHECK-DAG: pad_to_multiple_of = [128]
     # CHECK-DAG: padding_dimensions = [1]
     # CHECK-DAG: padding_values = [4.200000e+01 : f32]
     # CHECK-DAG: transpose_paddings = {{\[}}[1, 0], [0, 1]]