[mlir][python] Move results types to keyword-only arg.

[jpienaar]

Summary

Previously result types were specified at the front of the builder args. But
this meant that when the build time type inference was added the python API
changed and folks needed to update call sites. Instead move result types to
keyword args and make it optional in the case where the result type can be
inferred. This uniformly uses results for the arguments name rather than
attempt to expand or special case it (did consider still supporting result and
results and could be convinced that is better). This allows adding type
inference without breaking change and also brings the arguments to the fore and
more aligned with ODS def.

[jpienaar]

Rebase

[ftynse]

There are several points I'd like to discuss regarding this design choice:

1. This makes optionality confusing: some ops require result types to be provided and some others do not. It is not clear when the kwarg can be omitted (and we don't generate docs indicating that AFAIK). Furthermore, we use kwarg-only arguments for optional or default-valued attributes, using it for _mandatory_ results would make it confusing.
2. This puts all result type into a flat list, instead of grouping them per "out" field of the op definition in ODS, which may result in less readable builder calls.
3. The change was originally motivated by avoiding the breakage when result type inference was being introduced. It has landed a while ago, so this change will now create the breakage it sought to avoid.
4. Nit: what happens in case of a name conflict, i.e., when there is an attribute called results?

This change looks great for a more narrow use case: overriding the inferred types. I am supportive of it in a narrower scope: provide an override_result_types (longer name to decrease the likelihood of name clash) kwarg only for the ops for which we can infer result types. It sounds non-breaking for any of the existing code and will enable more functionality.

[jpienaar]

The change was originally motivated by avoiding the breakage when result type inference was being introduced. It has landed a while ago, so this change will now create the breakage it sought to avoid.

This is a breaking change as is, but also adding result type inference to an op is such still today. So if you have an op and you refine it's modelling by adding type inference, it breaks python side.

It is the easiest staging to only enable setting (and avoiding inference) when set and have it be optional in that case. But we still have the failure there when folks change which seems unfortunate - so it's question of breaking and setting scene for avoiding breakages later or having system that encourages small breakages as folks model ops more (and I'd suspect type inference being the common case).

Furthermore, we use kwarg-only arguments for optional or default-valued attributes, using it for _mandatory_ results would make it confusing

We use it for location too which is a required field.

Fair point that it is not documented for which may be elided.

This puts all result type into a flat list, instead of grouping them per "out" field of the op definition in ODS, which may result in less readable builder calls

Funnily I felt the opposite about this, the result type names made it difficult to know what was what when defining the op (is this an operand, attribute or result, if I want to set the result let me go look up the op in ODS). Making the interface more uniform was the intention and I think matches the C++ API closer too.

[ftynse]

In D126238#4056358, @jpienaar wrote:

The change was originally motivated by avoiding the breakage when result type inference was being introduced. It has landed a while ago, so this change will now create the breakage it sought to avoid.

This is a breaking change as is, but also adding result type inference to an op is such still today. So if you have an op and you refine it's modelling by adding type inference, it breaks python side.

It is the easiest staging to only enable setting (and avoiding inference) when set and have it be optional in that case. But we still have the failure there when folks change which seems unfortunate - so it's question of breaking and setting scene for avoiding breakages later or having system that encourages small breakages as folks model ops more (and I'd suspect type inference being the common case).

I'd generally place adding type inference into the "structural changes to the op" category, similarly to adding an output or an operand, which comes with an expectation that things will break. It may even be desirable that things break in this case as it will prompt the users to re-examine their usage in the light of op changes. (Arguably, it's not the case for type inference, where the worst case would be some duplicate type logic that keeps happening even though it could be subsumed by type inference).

Furthermore, we use kwarg-only arguments for optional or default-valued attributes, using it for _mandatory_ results would make it confusing

We use it for location too which is a required field.

And for the insertion point, both of which are typically provided through context managers. I haven't seen explicit loc= being used in the wild, up to the point that I suspect it may no longer work :)

This puts all result type into a flat list, instead of grouping them per "out" field of the op definition in ODS, which may result in less readable builder calls

Funnily I felt the opposite about this, the result type names made it difficult to know what was what when defining the op (is this an operand, attribute or result, if I want to set the result let me go look up the op in ODS). Making the interface more uniform was the intention and I think matches the C++ API closer too.

I agree that it is difficult to differentiate results from operands in a long list of ops. This is a slightly different problem from listing all results in the _single_ list. And that is already solved by Python allowing keywords even for positional arguments: one can write dialect.MyOp(first_result=type_1, second_result_variadic=[type_2, type_3], third_result=type_4, first_operand=value) now and would have to write dialect.MyOp(first_operand=value, results=[type_1, [type_2, type_3], type_4]) with this change.

mlir/python/mlir/dialects/_func_ops_ext.py

 
 ARGUMENT_ATTRIBUTE_NAME = "arg_attrs"
 RESULT_ATTRIBUTE_NAME = "res_attrs"
 
 class ConstantOp:
   """Specialization for the constant op class."""
 
   def __init__(self, result: Type, value: Attribute, *, loc=None, ip=None):
-    super().__init__(result, value, loc=loc, ip=ip)
+    super().__init__(value, results=[result], loc=loc, ip=ip)
 
   @property
   def type(self):
     return self.results[0].type
 
 
 class FuncOp:
   """Specialization for the func op class."""
if isinstance(calleeOrResults, FuncOp):
             "when constructing a call to a function, expected " +
             "the second argument to be a list of call arguments, " +
             f"got {type(argumentsOrCallee)}")
       if arguments is not None:
         raise ValueError("unexpected third argument when constructing a call" +
                          "to a function")
 
       super().__init__(
-          calleeOrResults.type.results,
           FlatSymbolRefAttr.get(
               calleeOrResults.name.value,
               context=_get_default_loc_context(loc)),
           argumentsOrCallee,
+          results=calleeOrResults.type.results,
           loc=loc,
           ip=ip)
       return
 
     if isinstance(argumentsOrCallee, list):
       raise ValueError("when constructing a call to a function by name, " +
                        "expected the second argument to be a string or a " +
                        f"FlatSymbolRefAttr, got {type(argumentsOrCallee)}")
 
     if isinstance(argumentsOrCallee, FlatSymbolRefAttr):
       super().__init__(
-          calleeOrResults, argumentsOrCallee, arguments, loc=loc, ip=ip)
+          argumentsOrCallee, arguments, results=calleeOrResults, loc=loc, ip=ip)
     elif isinstance(argumentsOrCallee, str):
       super().__init__(
-          calleeOrResults,
           FlatSymbolRefAttr.get(
               argumentsOrCallee, context=_get_default_loc_context(loc)),
           arguments,
+          results=calleeOrResults,
           loc=loc,
           ip=ip)

mlir/python/mlir/dialects/_loop_transform_ops_ext.py

class GetParentForOp:
 
   def __init__(self,
                target: Union[Operation, Value],
                *,
                num_loops: int = 1,
                ip=None,
                loc=None):
     super().__init__(
-        pdl.OperationType.get(),
         _get_op_result_or_value(target),
         num_loops=_get_int64_attr(num_loops, default_value=1),
+        results=[pdl.OperationType.get()],
         ip=ip,
         loc=loc)
 
 
 class LoopOutlineOp:
   """Extension for LoopOutlineOp."""
 
   def __init__(self,
                target: Union[Operation, Value],
                *,
                func_name: Union[str, StringAttr],
                ip=None,
                loc=None):
     super().__init__(
-        pdl.OperationType.get(),
         _get_op_result_or_value(target),
         func_name=(func_name if isinstance(func_name, StringAttr) else
                    StringAttr.get(func_name)),
+        results=[pdl.OperationType.get()],
         ip=ip,
         loc=loc)
 
 
 class LoopPeelOp:
   """Extension for LoopPeelOp."""
 
   def __init__(self,
                target: Union[Operation, Value],
                *,
                fail_if_already_divisible: Union[bool, BoolAttr] = False,
                ip=None,
                loc=None):
     super().__init__(
-        pdl.OperationType.get(),
         _get_op_result_or_value(target),
         fail_if_already_divisible=(fail_if_already_divisible if isinstance(
             fail_if_already_divisible, BoolAttr) else
                                    BoolAttr.get(fail_if_already_divisible)),
+        results=[pdl.OperationType.get()],
         ip=ip,
         loc=loc)
 
 
 class LoopPipelineOp:
   """Extension for LoopPipelineOp."""
 
   def __init__(self,
                target: Union[Operation, Value],
                *,
                iteration_interval: Optional[Union[int, IntegerAttr]] = None,
                read_latency: Optional[Union[int, IntegerAttr]] = None,
                ip=None,
                loc=None):
     super().__init__(
-        pdl.OperationType.get(),
         _get_op_result_or_value(target),
         iteration_interval=_get_int64_attr(iteration_interval, default_value=1),
         read_latency=_get_int64_attr(read_latency, default_value=10),
+        results=[pdl.OperationType.get()],
         ip=ip,
         loc=loc)
 
 
 class LoopUnrollOp:
   """Extension for LoopUnrollOp."""
 
   def __init__(self,

mlir/python/mlir/dialects/_memref_ops_ext.py

Args:
         buffers.
       loc: user-visible location of the operation.
       ip: insertion point.
     """
     memref_resolved = _get_op_result_or_value(memref)
     indices_resolved = [] if indices is None else _get_op_results_or_values(
         indices)
     return_type = MemRefType(memref_resolved.type).element_type
-    super().__init__(return_type, memref, indices_resolved, loc=loc, ip=ip)
+    super().__init__(memref, indices_resolved, results=[return_type], loc=loc, ip=ip)

mlir/python/mlir/dialects/_pdl_ops_ext.py

def __init__(self,
                results: Sequence[Type],
                name: Union[str, StringAttr],
                args: Sequence[Union[OpView, Operation, Value]] = [],
                *,
                loc=None,
                ip=None):
     name = _get_str_attr(name)
     args = _get_values(args)
-    super().__init__(results, name, args, loc=loc, ip=ip)
+    super().__init__(name, args, results=results, loc=loc, ip=ip)
 
 
 class AttributeOp:
   """Specialization for PDL attribute op class."""
 
   def __init__(self,
                type: Optional[Union[OpView, Operation, Value]] = None,
                value: Optional[Attribute] = None,
                *,
                loc=None,
                ip=None):
     type = type if type is None else _get_value(type)
     result = pdl.AttributeType.get()
-    super().__init__(result, type=type, value=value, loc=loc, ip=ip)
+    super().__init__(value=value, type=type, results=[result], loc=loc, ip=ip)
 
 
 class EraseOp:
   """Specialization for PDL erase op class."""
 
   def __init__(self,
                operation: Optional[Union[OpView, Operation, Value]] = None,
                *,
                loc=None,
                ip=None):
     operation = _get_value(operation)
     super().__init__(operation, loc=loc, ip=ip)
 
 
 class OperandOp:
   """Specialization for PDL operand op class."""
 
   def __init__(self,
                type: Optional[Union[OpView, Operation, Value]] = None,
                *,
                loc=None,
                ip=None):
     type = type if type is None else _get_value(type)
     result = pdl.ValueType.get()
-    super().__init__(result, type=type, loc=loc, ip=ip)
+    super().__init__(type=type, results=[result], loc=loc, ip=ip)
 
 
 class OperandsOp:
   """Specialization for PDL operands op class."""
 
   def __init__(self,
                types: Optional[Union[OpView, Operation, Value]] = None,
                *,
                loc=None,
                ip=None):
     types = types if types is None else _get_value(types)
     result = pdl.RangeType.get(pdl.ValueType.get())
-    super().__init__(result, type=types, loc=loc, ip=ip)
+    super().__init__(type=types, results=[result], loc=loc, ip=ip)
 
 
 class OperationOp:
   """Specialization for PDL operand op class."""
 
   def __init__(self,
                name: Optional[Union[str, StringAttr]] = None,
                args: Sequence[Union[OpView, Operation, Value]] = [],
                attributes: Mapping[str, Union[OpView, Operation, Value]] = {},
                types: Sequence[Union[OpView, Operation, Value]] = [],
                *,
                loc=None,
                ip=None):
     name = name if name is None else _get_str_attr(name)
     args = _get_values(args)
     attributeNames = []
     attributeValues = []
     for attrName, attrValue in attributes.items():
       attributeNames.append(StringAttr.get(attrName))
       attributeValues.append(_get_value(attrValue))
     attributeNames = ArrayAttr.get(attributeNames)
     types = _get_values(types)
     result = pdl.OperationType.get()
-    super().__init__(result, args, attributeValues, attributeNames, types, name=name, loc=loc, ip=ip)
+    super().__init__(args, attributeValues, attributeNames, types, name=name, results=[result], loc=loc, ip=ip)
 
 
 class PatternOp:
   """Specialization for PDL pattern op class."""
 
   def __init__(self,
                benefit: Union[IntegerAttr, int],
                name: Optional[Union[StringAttr, str]] = None,
def __init__(self,
                parent: Union[OpView, Operation, Value],
                index: Union[IntegerAttr, int],
                *,
                loc=None,
                ip=None):
     index = _get_int_attr(32, index)
     parent = _get_value(parent)
     result = pdl.ValueType.get()
-    super().__init__(result, parent, index, loc=loc, ip=ip)
+    super().__init__(parent, index, results=[result], loc=loc, ip=ip)
 
 
 class ResultsOp:
   """Specialization for PDL results op class."""
 
   def __init__(self,
                result: Type,
                parent: Union[OpView, Operation, Value],
                index: Optional[Union[IntegerAttr, int]] = None,
                *,
                loc=None,
                ip=None):
     parent = _get_value(parent)
     index = index if index is None else _get_int_attr(32, index)
-    super().__init__(result, parent, index=index, loc=loc, ip=ip)
+    super().__init__(parent, index=index, results=[result], loc=loc, ip=ip)
 
 
 class RewriteOp:
   """Specialization for PDL rewrite op class."""
 
   def __init__(self,
                root: Optional[Union[OpView, Operation, Value]] = None,
                name: Optional[Union[StringAttr, str]] = None,
class TypeOp:
 
   def __init__(self,
                type: Optional[Union[TypeAttr, Type]] = None,
                *,
                loc=None,
                ip=None):
     type = type if type is None else _get_type_attr(type)
     result = pdl.TypeType.get()
-    super().__init__(result, type=type, loc=loc, ip=ip)
+    super().__init__(type=type, results=[result], loc=loc, ip=ip)
 
 
 class TypesOp:
   """Specialization for PDL types op class."""
 
   def __init__(self,
                types: Sequence[Union[TypeAttr, Type]] = [],
                *,
                loc=None,
                ip=None):
     types = _get_array_attr([_get_type_attr(ty) for ty in types])
     types = None if not types else types
     result = pdl.RangeType.get(pdl.TypeType.get())
-    super().__init__(result, types=types, loc=loc, ip=ip)
+    super().__init__(types=types, results=[result], loc=loc, ip=ip)

mlir/python/mlir/dialects/_structured_transform_ops_ext.py

) -> ArrayAttr:
   return ArrayAttr.get([_get_int_array_attr(value) for value in values])
 
 
 class DecomposeOp:
   """Specialization for DecomposeOp class."""
 
   def __init__(self, target: Union[Operation, Value], *, loc=None, ip=None):
     super().__init__(
-        pdl.OperationType.get(),
         _get_op_result_or_value(target),
+        results=[pdl.OperationType.get()],
         loc=loc,
         ip=ip)
 
 
 class GeneralizeOp:
   """Specialization for GeneralizeOp class."""
 
   def __init__(self, target: Union[Operation, Value], *, loc=None, ip=None):
     super().__init__(
-        pdl.OperationType.get(),
         _get_op_result_or_value(target),
+        results=[pdl.OperationType.get()],
         loc=loc,
         ip=ip)
 
 
 class InterchangeOp:
   """Specialization for InterchangeOp class."""
 
   def __init__(self,
                target: Union[Operation, Value],
                *,
                iterator_interchange: OptionalIntList = None,
                loc=None,
                ip=None):
     pdl_operation_type = pdl.OperationType.get()
     interchange_attr = _get_int_array_attr(iterator_interchange)
     super().__init__(
-        pdl_operation_type,
         _get_op_result_or_value(target),
         iterator_interchange=interchange_attr,
+        results=[pdl_operation_type],
         loc=loc,
         ip=ip)
 
 
 class PadOp:
   """Specialization for PadOp class."""
 
   def __init__(self,
def __init__(self,
                ip=None):
     pdl_operation_type = pdl.OperationType.get()
     padding_values_attr = _get_array_attr(padding_values)
     padding_dimensions_attr = _get_int_array_attr(padding_dimensions)
     pack_paddings_attr = _get_int_array_attr(pack_paddings)
     hoist_paddings_attr = _get_int_array_attr(hoist_paddings)
     transpose_paddings_attr = _get_int_int_array_attr(transpose_paddings)
     super().__init__(
-        pdl_operation_type,
         _get_op_result_or_value(target),
         padding_values=padding_values_attr,
         padding_dimensions=padding_dimensions_attr,
         pack_paddings=pack_paddings_attr,
         hoist_paddings=hoist_paddings_attr,
         transpose_paddings=transpose_paddings_attr,
+        results=[pdl_operation_type],
         loc=loc,
         ip=ip)
 
 
 class ScalarizeOp:
   """Specialization for ScalarizeOp class."""
 
   def __init__(self, target: Union[Operation, Value], *, loc=None, ip=None):
     pdl_operation_type = pdl.OperationType.get()
     super().__init__(
-        pdl_operation_type, _get_op_result_or_value(target), loc=loc, ip=ip)
+        _get_op_result_or_value(target), results=[pdl_operation_type], loc=loc, ip=ip)
 
 
 class TileOp:
   """Specialization for TileOp class."""
 
   def __init__(self,
                target: Union[Operation, Value],
                *,
                sizes: OptionalIntList = None,
                interchange: OptionalIntList = None,
                loc=None,
                ip=None):
     pdl_operation_type = pdl.OperationType.get()
     sizes_attr = _get_int_array_attr(sizes)
     num_loops = sum(
         v if v == 0 else 1 for v in self.__extract_values(sizes_attr))
     super().__init__(
-        pdl_operation_type, [pdl_operation_type] * num_loops,
         _get_op_result_or_value(target),
         sizes=sizes_attr,
         interchange=_get_int_array_attr(interchange) if interchange else None,
+        results=[pdl_operation_type] * (num_loops + 1),
         loc=loc,
         ip=ip)
 
   def __extract_values(self, attr: Optional[ArrayAttr]) -> List[int]:
     if not attr:
       return []
     return [IntegerAttr(element).value for element in attr]
 
 
 class VectorizeOp:
   """Specialization for VectorizeOp class."""
 
   def __init__(self,
                target: Union[Operation, Value],
                *,
                vectorize_padding: Union[bool, BoolAttr] = False,
                loc=None,
                ip=None):
     pdl_operation_type = pdl.OperationType.get()
     if isinstance(vectorize_padding, bool):
       vectorize_padding = BoolAttr.get(vectorize_padding)
     super().__init__(
-        pdl_operation_type,
         _get_op_result_or_value(target),
         vectorize_padding=vectorize_padding,
+        results=[pdl_operation_type],
         loc=loc,
         ip=ip)

mlir/python/mlir/dialects/_transform_ops_ext.py

if isinstance(value, Attribute):
     return value
   return FlatSymbolRefAttr.get(value)
 
 
 class GetClosestIsolatedParentOp:
 
   def __init__(self, target: Union[Operation, Value], *, loc=None, ip=None):
     super().__init__(
-        pdl.OperationType.get(),
         _get_op_result_or_value(target),
+        results=[pdl.OperationType.get()],
         loc=loc,
         ip=ip)
 
 
 class PDLMatchOp:
 
   def __init__(self,
                target: Union[Operation, Value],
                pattern_name: Union[Attribute, str],
                *,
                loc=None,
                ip=None):
     super().__init__(
-        pdl.OperationType.get(),
         _get_op_result_or_value(target),
         _get_symbol_ref_attr(pattern_name),
+        results=[pdl.OperationType.get()],
         loc=loc,
         ip=ip)
 
 
 class SequenceOp:
 
   @overload
   def __init__(self, resultsOrRoot: Sequence[Type],
                optionalRoot: Optional[Union[Operation, Value]]):
     ...
 
   @overload
   def __init__(self, resultsOrRoot: Optional[Union[Operation, Value]],
                optionalRoot: NoneType):
     ...
 
   def __init__(self, resultsOrRoot=None, optionalRoot=None):
     results = resultsOrRoot if isinstance(resultsOrRoot, Sequence) else []
     root = (
         resultsOrRoot
         if not isinstance(resultsOrRoot, Sequence) else optionalRoot)
     root = _get_op_result_or_value(root) if root else None
-    super().__init__(results_=results, root=root)
+    super().__init__(results=results, root=root)
     self.regions[0].blocks.append(pdl.OperationType.get())
 
   @property
   def body(self) -> Block:
     return self.regions[0].blocks[0]
 
   @property
   def bodyTarget(self) -> Value:

mlir/python/mlir/dialects/linalg/opdsl/lang/emitter.py

for arg_def in all_arg_defs:
         if idx < len(ins) and ShapedType(ins[idx].type).rank == 0:
           indexing_maps.append(scalar_map)
         else:
           indexing_maps.append(tensor_map)
     indexing_maps_attr = ArrayAttr.get(
         [AffineMapAttr.get(am) for am in indexing_maps])
 
   generic_op = linalg.GenericOp(
-      result_tensors=result_types,
+      results=result_types,
       inputs=ins,
       outputs=outs,
       indexing_maps=indexing_maps_attr,
       iterator_types=iterator_types_attr,
       doc=None,  # TODO: Make optional.
       library_call=None)  # TODO: Make optional.
 
   # Construct the body.
elif _is_floating_point_type(to_type):
       return self._cast_to_floating_point(to_type, operand, is_unsigned_cast)
 
   def _cast_to_integer(self, to_type: Type, operand: Value,
                        is_unsigned_cast: bool) -> Value:
     to_width = IntegerType(to_type).width
     operand_type = operand.type
     if _is_floating_point_type(operand_type):
       if is_unsigned_cast:
-        return arith.FPToUIOp(to_type, operand).result
-      return arith.FPToSIOp(to_type, operand).result
+        return arith.FPToUIOp(operand, results=[to_type]).result
+      return arith.FPToSIOp(operand, results=[to_type]).result
     if _is_index_type(operand_type):
-      return arith.IndexCastOp(to_type, operand).result
+      return arith.IndexCastOp(operand, results=[to_type]).result
     # Assume integer.
     from_width = IntegerType(operand_type).width
     if to_width > from_width:
       if is_unsigned_cast:
-        return arith.ExtUIOp(to_type, operand).result
-      return arith.ExtSIOp(to_type, operand).result
+        return arith.ExtUIOp(operand, results=[to_type]).result
+      return arith.ExtSIOp(operand, results=[to_type]).result
     elif to_width < from_width:
-      return arith.TruncIOp(to_type, operand).result
+      return arith.TruncIOp(operand, results=[to_type]).result
     raise ValueError(f"Unable to cast body expression from {operand_type} to "
                      f"{to_type}")
 
   def _cast_to_floating_point(self, to_type: Type, operand: Value,
                               is_unsigned_cast: bool) -> Value:
     operand_type = operand.type
     if _is_integer_type(operand_type):
       if is_unsigned_cast:
-        return arith.UIToFPOp(to_type, operand).result
-      return arith.SIToFPOp(to_type, operand).result
+        return arith.UIToFPOp(operand, results=[to_type]).result
+      return arith.SIToFPOp(operand, results=[to_type]).result
     # Assume FloatType.
     to_width = _get_floating_point_width(to_type)
     from_width = _get_floating_point_width(operand_type)
     if to_width > from_width:
-      return arith.ExtFOp(to_type, operand).result
+      return arith.ExtFOp(operand, results=[to_type]).result
     elif to_width < from_width:
-      return arith.TruncFOp(to_type, operand).result
+      return arith.TruncFOp(operand, results=[to_type]).result
     raise ValueError(f"Unable to cast body expression from {operand_type} to "
                      f"{to_type}")
 
   def _type_cast_signed(self, type_var_name: str, operand: Value) -> Value:
     return self._cast(type_var_name, operand, False)
 
   def _type_cast_unsigned(self, type_var_name: str, operand: Value) -> Value:
     return self._cast(type_var_name, operand, True)

mlir/test/mlir-tblgen/op-python-bindings.td

 // CHECK: @_ods_cext.register_operation(_Dialect)
 // CHECK: class AttrSizedOperandsOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.attr_sized_operands"
 // CHECK: _ODS_OPERAND_SEGMENTS = [-1,1,0,]
 def AttrSizedOperandsOp : TestOp<"attr_sized_operands",
                                  [AttrSizedOperandSegments]> {
   // CHECK: def __init__(self, variadic1, non_variadic, *, variadic2=None, loc=None, ip=None):
   // CHECK:   operands = []
-  // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   regions = None
   // CHECK:   operands.append(_get_op_results_or_values(variadic1))
   // CHECK:   operands.append(_get_op_result_or_value(non_variadic))
   // CHECK:   operands.append(_get_op_result_or_value(variadic2) if variadic2 is not None else None)
   // CHECK:   _ods_successors = None
   // CHECK:   super().__init__(self.build_generic(
   // CHECK:     attributes=attributes, results=results, operands=operands,

 }
 
 // CHECK: @_ods_cext.register_operation(_Dialect)
 // CHECK: class AttrSizedResultsOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.attr_sized_results"
 // CHECK: _ODS_RESULT_SEGMENTS = [0,1,-1,]
 def AttrSizedResultsOp : TestOp<"attr_sized_results",
                                [AttrSizedResultSegments]> {
-  // CHECK: def __init__(self, variadic1, non_variadic, variadic2, *, loc=None, ip=None):
+  // CHECK: def __init__(self, *, loc=None, ip=None, results):
   // CHECK:   operands = []
-  // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   regions = None
-  // CHECK:   if variadic1 is not None: results.append(variadic1)
-  // CHECK:   results.append(non_variadic)
-  // CHECK:   results.append(variadic2)
   // CHECK:   _ods_successors = None
   // CHECK:   super().__init__(self.build_generic(
   // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     successors=_ods_successors, regions=regions, loc=loc, ip=ip))
 
   // CHECK: @builtins.property
   // CHECK: def variadic1(self):
   // CHECK:   result_range = _ods_segmented_accessor(

 // CHECK: @_ods_cext.register_operation(_Dialect)
 // CHECK: class AttributedOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.attributed_op"
 // CHECK-NOT: _ODS_OPERAND_SEGMENTS
 // CHECK-NOT: _ODS_RESULT_SEGMENTS
 def AttributedOp : TestOp<"attributed_op"> {
   // CHECK: def __init__(self, i32attr, in_, *, optionalF32Attr=None, unitAttr=None, loc=None, ip=None):
   // CHECK:   operands = []
-  // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   regions = None
   // CHECK:   attributes["i32attr"] = i32attr
   // CHECK:   if optionalF32Attr is not None: attributes["optionalF32Attr"] = optionalF32Attr
   // CHECK:   if bool(unitAttr): attributes["unitAttr"] = _ods_ir.UnitAttr.get(
   // CHECK:     _ods_get_default_loc_context(loc))
   // CHECK:   attributes["in"] = in_
   // CHECK:   _ods_successors = None

 // CHECK: @_ods_cext.register_operation(_Dialect)
 // CHECK: class AttributedOpWithOperands(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.attributed_op_with_operands"
 // CHECK-NOT: _ODS_OPERAND_SEGMENTS
 // CHECK-NOT: _ODS_RESULT_SEGMENTS
 def AttributedOpWithOperands : TestOp<"attributed_op_with_operands"> {
   // CHECK: def __init__(self, _gen_arg_0, _gen_arg_2, *, in_=None, is_=None, loc=None, ip=None):
   // CHECK:   operands = []
-  // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   regions = None
   // CHECK:   operands.append(_get_op_result_or_value(_gen_arg_0))
   // CHECK:   operands.append(_get_op_result_or_value(_gen_arg_2))
   // CHECK:   if bool(in_): attributes["in"] = _ods_ir.UnitAttr.get(
   // CHECK:     _ods_get_default_loc_context(loc))
   // CHECK:   if is_ is not None: attributes["is"] = is_
   // CHECK:   _ods_successors = None

 }
 
 // CHECK: @_ods_cext.register_operation(_Dialect)
 // CHECK: class DefaultValuedAttrsOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.default_valued_attrs"
 def DefaultValuedAttrsOp : TestOp<"default_valued_attrs"> {
   // CHECK: def __init__(self, *, arr=None, unsupported=None, loc=None, ip=None):
   // CHECK:   operands = []
-  // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   regions = None
   // CHECK:   attributes["arr"] = arr if arr is not None else _ods_ir.ArrayAttr.get([])
   // CHECK:   unsupported is not None, "attribute unsupported must be specified"
   // CHECK:   _ods_successors = None
+  // CHECK:   results = []
   // CHECK:   super().__init__(self.build_generic(
   // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     successors=_ods_successors, regions=regions, loc=loc, ip=ip))
 
   let arguments = (ins DefaultValuedAttr<I64ArrayAttr, "{}">:$arr,
                        DefaultValuedAttr<I64ArrayAttr, "dummy_func()">:$unsupported);
   let results = (outs);
 }
 
 // CHECK-LABEL: OPERATION_NAME = "test.derive_result_types_op"
 def DeriveResultTypesOp : TestOp<"derive_result_types_op", [FirstAttrDerivedResultType]> {
-  // CHECK: def __init__(self, type, *, loc=None, ip=None):
+  // CHECK: def __init__(self, type, *, loc=None, ip=None, results=[]):
   // CHECK:   operands = []
-  // CHECK:   results = []
   // CHECK:   _ods_result_type_source_attr = attributes["type"]
   // CHECK:   _ods_derived_result_type = (
   // CHECK:       _ods_ir.TypeAttr(_ods_result_type_source_attr).value
   // CHECK:       if _ods_ir.TypeAttr.isinstance(_ods_result_type_source_attr) else
   // CHECK:       _ods_result_type_source_attr.type)
-  // CHECK:   results.extend([_ods_derived_result_type] * 2)
+  // CHECK:   results = [_ods_derived_result_type] * 2
   let arguments = (ins TypeAttr:$type);
   let results = (outs AnyType:$res, AnyType);
 }
 
 // CHECK-LABEL: OPERATION_NAME = "test.derive_result_types_variadic_op"
 def DeriveResultTypesVariadicOp : TestOp<"derive_result_types_variadic_op", [FirstAttrDerivedResultType]> {
-  // CHECK: def __init__(self, res, _gen_res_1, type, *, loc=None, ip=None):
+  // CHECK: def __init__(self, type, *, loc=None, ip=None, results):
   let arguments = (ins TypeAttr:$type);
   let results = (outs AnyType:$res, Variadic<AnyType>);
 }
 
 // CHECK: @_ods_cext.register_operation(_Dialect)
 // CHECK: class EmptyOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.empty"
 def EmptyOp : TestOp<"empty">;
   // CHECK: def __init__(self, *, loc=None, ip=None):
   // CHECK:   operands = []
-  // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   regions = None
   // CHECK:   _ods_successors = None
   // CHECK:   super().__init__(self.build_generic(
   // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     successors=_ods_successors, regions=regions, loc=loc, ip=ip))
 
 
 // CHECK-LABEL: OPERATION_NAME = "test.infer_result_types_implied_op"
 def InferResultTypesImpliedOp : TestOp<"infer_result_types_implied_op"> {
-  // CHECK:  def __init__(self, *, loc=None, ip=None):
+  // CHECK:  def __init__(self, *, loc=None, ip=None, results=[]):
   // CHECK:    operands = []
-  // CHECK:    results = []
   // CHECK:    _ods_context = _ods_get_default_loc_context(loc)
   // CHECK:    results = _ods_ir.InferTypeOpInterface(InferResultTypesImpliedOp).inferReturnTypes(
   // CHECK:        operands=operands,
   // CHECK:        attributes=_ods_ir.DictAttr.get(attributes, context=_ods_context),
   // CHECK:        context=_ods_context,
   // CHECK:        loc=loc)
   let results = (outs I32:$i32, F32:$f32);
 }
 
 // CHECK-LABEL: OPERATION_NAME = "test.infer_result_types_op"
 def InferResultTypesOp : TestOp<"infer_result_types_op", [InferTypeOpInterface]> {
-  // CHECK:  def __init__(self, *, loc=None, ip=None):
+  // CHECK:  def __init__(self, *, loc=None, ip=None, results=[]):
   // CHECK:    operands = []
-  // CHECK:    results = []
   // CHECK:    _ods_context = _ods_get_default_loc_context(loc)
   // CHECK:    results = _ods_ir.InferTypeOpInterface(InferResultTypesOp).inferReturnTypes(
   // CHECK:        operands=operands,
   // CHECK:        attributes=_ods_ir.DictAttr.get(attributes, context=_ods_context),
   // CHECK:        context=_ods_context,
   // CHECK:        loc=loc)
   let results = (outs AnyType, AnyType, AnyType);
 }
 
 // CHECK: @_ods_cext.register_operation(_Dialect)
 // CHECK: class MissingNamesOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.missing_names"
 def MissingNamesOp : TestOp<"missing_names"> {
-  // CHECK: def __init__(self, i32, _gen_res_1, i64, _gen_arg_0, f32, _gen_arg_2, *, loc=None, ip=None):
+  // CHECK: def __init__(self, _gen_arg_0, f32, _gen_arg_2, *, loc=None, ip=None, results):
   // CHECK:   operands = []
-  // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   regions = None
   // CHECK:   operands.append(_get_op_result_or_value(_gen_arg_0))
   // CHECK:   operands.append(_get_op_result_or_value(f32))
   // CHECK:   operands.append(_get_op_result_or_value(_gen_arg_2))
-  // CHECK:   results.append(i32)
-  // CHECK:   results.append(_gen_res_1)
-  // CHECK:   results.append(i64)
   // CHECK:   _ods_successors = None
   // CHECK:   super().__init__(self.build_generic(
   // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     successors=_ods_successors, regions=regions, loc=loc, ip=ip))
 
   // CHECK: @builtins.property
   // CHECK: def f32(self):
   // CHECK:   return self.operation.operands[1]

 // CHECK: class OneOptionalOperandOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.one_optional_operand"
 // CHECK-NOT: _ODS_OPERAND_SEGMENTS
 // CHECK-NOT: _ODS_RESULT_SEGMENTS
 def OneOptionalOperandOp : TestOp<"one_optional_operand"> {
   let arguments = (ins AnyType:$non_optional, Optional<AnyType>:$optional);
   // CHECK: def __init__(self, non_optional, *, optional=None, loc=None, ip=None):
   // CHECK:   operands = []
-  // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   regions = None
   // CHECK:   operands.append(_get_op_result_or_value(non_optional))
   // CHECK:   if optional is not None: operands.append(_get_op_result_or_value(optional))
   // CHECK:   _ods_successors = None
   // CHECK:   super().__init__(self.build_generic(
   // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     successors=_ods_successors, regions=regions, loc=loc, ip=ip))

 // CHECK: @_ods_cext.register_operation(_Dialect)
 // CHECK: class OneVariadicOperandOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.one_variadic_operand"
 // CHECK-NOT: _ODS_OPERAND_SEGMENTS
 // CHECK-NOT: _ODS_RESULT_SEGMENTS
 def OneVariadicOperandOp : TestOp<"one_variadic_operand"> {
   // CHECK: def __init__(self, non_variadic, variadic, *, loc=None, ip=None):
   // CHECK:   operands = []
-  // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   regions = None
   // CHECK:   operands.append(_get_op_result_or_value(non_variadic))
   // CHECK:   operands.extend(_get_op_results_or_values(variadic))
   // CHECK:   _ods_successors = None
   // CHECK:   super().__init__(self.build_generic(
   // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     successors=_ods_successors, regions=regions, loc=loc, ip=ip))

 }
 
 // CHECK: @_ods_cext.register_operation(_Dialect)
 // CHECK: class OneVariadicResultOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.one_variadic_result"
 // CHECK-NOT: _ODS_OPERAND_SEGMENTS
 // CHECK-NOT: _ODS_RESULT_SEGMENTS
 def OneVariadicResultOp : TestOp<"one_variadic_result"> {
-  // CHECK: def __init__(self, variadic, non_variadic, *, loc=None, ip=None):
+  // CHECK: def __init__(self, *, loc=None, ip=None, results):
   // CHECK:   operands = []
-  // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   regions = None
-  // CHECK:   results.extend(variadic)
-  // CHECK:   results.append(non_variadic)
   // CHECK:   _ods_successors = None
   // CHECK:   super().__init__(self.build_generic(
   // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     successors=_ods_successors, regions=regions, loc=loc, ip=ip))
 
   // CHECK: @builtins.property
   // CHECK: def variadic(self):
   // CHECK:   _ods_variadic_group_length = len(self.operation.results) - 2 + 1
   // CHECK:   return self.operation.results[0:0 + _ods_variadic_group_length]
   //
   // CHECK: @builtins.property
   // CHECK: def non_variadic(self):
   // CHECK:   _ods_variadic_group_length = len(self.operation.results) - 2 + 1
   // CHECK:   return self.operation.results[1 + _ods_variadic_group_length - 1]
   let results = (outs Variadic<AnyType>:$variadic, AnyType:$non_variadic);
 }
 
 // CHECK: @_ods_cext.register_operation(_Dialect)
 // CHECK: class PythonKeywordOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.python_keyword"
 def PythonKeywordOp : TestOp<"python_keyword"> {
   // CHECK: def __init__(self, in_, *, loc=None, ip=None):
   // CHECK:   operands = []
-  // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   regions = None
   // CHECK:   operands.append(_get_op_result_or_value(in_))
   // CHECK:   _ods_successors = None
   // CHECK:   super().__init__(self.build_generic(
   // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     successors=_ods_successors, regions=regions, loc=loc, ip=ip))
 
   // CHECK: @builtins.property
   // CHECK: def in_(self):
   // CHECK:   return self.operation.operands[0]
   let arguments = (ins AnyType:$in);
 }
 // CHECK-LABEL: OPERATION_NAME = "test.same_results"
 def SameResultsOp : TestOp<"same_results", [SameOperandsAndResultType]> {
-  // CHECK: def __init__(self, in1, in2, *, loc=None, ip=None):
+  // CHECK: def __init__(self, in1, in2, *, loc=None, ip=None, results=[]):
   // CHECK: operands = []
-  // CHECK: results = []
   // CHECK: operands.append
-  // CHECK: results.extend([operands[0].type] * 1)
+  // CHECK: results = [operands[0].type] * 1
   let arguments = (ins AnyType:$in1, AnyType:$in2);
   let results = (outs AnyType:$res);
 }
 
 // CHECK-LABEL: OPERATION_NAME = "test.same_results_variadic"
 def SameResultsVariadicOp : TestOp<"same_results_variadic", [SameOperandsAndResultType]> {
-  // CHECK: def __init__(self, res, in1, in2, *, loc=None, ip=None):
+  // CHECK: def __init__(self, in1, in2, *, loc=None, ip=None, results):
   let arguments = (ins AnyType:$in1, AnyType:$in2);
   let results = (outs Variadic<AnyType>:$res);
 }
 
 
 // CHECK: @_ods_cext.register_operation(_Dialect)
 // CHECK: class SameVariadicOperandSizeOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.same_variadic_operand"
def SameVariadicResultSizeOp : TestOp<"same_variadic_result",
   let results = (outs Variadic<AnyType>:$variadic1, AnyType:$non_variadic,
                  Variadic<AnyType>:$variadic2);
 }
 
 // CHECK: @_ods_cext.register_operation(_Dialect)
 // CHECK: class SimpleOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.simple"
 def SimpleOp : TestOp<"simple"> {
-  // CHECK: def __init__(self, i64, f64, i32, f32, *, loc=None, ip=None):
+  // CHECK: def __init__(self, i32, f32, *, loc=None, ip=None, results):
   // CHECK:   operands = []
-  // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   regions = None
   // CHECK:   operands.append(_get_op_result_or_value(i32))
   // CHECK:   operands.append(_get_op_result_or_value(f32))
-  // CHECK:   results.append(i64)
-  // CHECK:   results.append(f64)
   // CHECK:   _ods_successors = None
   // CHECK:   super().__init__(self.build_generic(
   // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     successors=_ods_successors, regions=regions, loc=loc, ip=ip))
 
   // CHECK: @builtins.property
   // CHECK: def i32(self):
   // CHECK:   return self.operation.operands[0]
def SimpleOp : TestOp<"simple"> {
   let results = (outs I64:$i64, AnyFloat:$f64);
 }
 
 // CHECK: class VariadicAndNormalRegionOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.variadic_and_normal_region"
 def VariadicAndNormalRegionOp : TestOp<"variadic_and_normal_region"> {
   // CHECK:  def __init__(self, num_variadic, *, loc=None, ip=None):
   // CHECK:    operands = []
-  // CHECK:    results = []
   // CHECK:    attributes = {}
   // CHECK:    regions = None
   // CHECK:    _ods_successors = None
   // CHECK:    regions = 2 + num_variadic
   // CHECK:    super().__init__(self.build_generic(
   // CHECK:      attributes=attributes, results=results, operands=operands,
   // CHECK:      successors=_ods_successors, regions=regions, loc=loc, ip=ip))
   let regions = (region AnyRegion:$region, AnyRegion, VariadicRegion<AnyRegion>:$variadic);
 
   // CHECK:  @builtins.property
   // CHECK:  def region(self):
   // CHECK:    return self.regions[0]
 
   // CHECK:  @builtins.property
   // CHECK:  def variadic(self):
   // CHECK:    return self.regions[2:]
 }
 
 // CHECK: class VariadicRegionOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.variadic_region"
 def VariadicRegionOp : TestOp<"variadic_region"> {
   // CHECK:  def __init__(self, num_variadic, *, loc=None, ip=None):
   // CHECK:    operands = []
-  // CHECK:    results = []
   // CHECK:    attributes = {}
   // CHECK:    regions = None
   // CHECK:    _ods_successors = None
   // CHECK:    regions = 0 + num_variadic
   // CHECK:    super().__init__(self.build_generic(
   // CHECK:      attributes=attributes, results=results, operands=operands,
   // CHECK:      successors=_ods_successors, regions=regions, loc=loc, ip=ip))
   let regions = (region VariadicRegion<AnyRegion>:$Variadic);

mlir/test/python/dialects/transform_structured_ext.py

-# RUN: %PYTHON %s | FileCheck %s
+# RUN: %PYTHON %s | tee /tmp/t1 | FileCheck %s
 
 from mlir.ir import *
 from mlir.dialects import transform
 from mlir.dialects import pdl
 from mlir.dialects.transform import structured
 
 
 def run(f):

mlir/test/python/dialects/vector.py

with InsertionPoint(module.body):
     mask_type = VectorType.get(vector_type.shape, IntegerType.get_signless(1))
     identity_map = AffineMap.get_identity(vector_type.rank)
     identity_map_attr = AffineMapAttr.get(identity_map)
     f = func.FuncOp("transfer_read",
                           ([memref_type, index_type,
                             F32Type.get(), mask_type], []))
     with InsertionPoint(f.add_entry_block()):
       A, zero, padding, mask = f.arguments
-      vector.TransferReadOp(vector_type, A, [zero, zero], identity_map_attr,
-                            padding, mask=mask)
-      vector.TransferReadOp(vector_type, A, [zero, zero], identity_map_attr,
-                            padding)
+      vector.TransferReadOp(A, [zero, zero], identity_map_attr,
+                            padding, mask=mask, results=[vector_type])
+      vector.TransferReadOp(A, [zero, zero], identity_map_attr,
+                            padding, results=[vector_type])
       func.ReturnOp([])
 
   # CHECK: @transfer_read(%[[MEM:.*]]: memref<?x?xf32>, %[[IDX:.*]]: index,
   # CHECK: %[[PAD:.*]]: f32, %[[MASK:.*]]: vector<2x3xi1>)
   # CHECK: vector.transfer_read %[[MEM]][%[[IDX]], %[[IDX]]], %[[PAD]], %[[MASK]]
   # CHECK: vector.transfer_read %[[MEM]][%[[IDX]], %[[IDX]]], %[[PAD]]
   # CHECK-NOT: %[[MASK]]
   print(module)

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

 /// Template for the default auto-generated builder.
 ///   {0} is a comma-separated list of builder arguments, including the trailing
 ///       `loc` and `ip`;
 ///   {1} is the code populating `operands`, `results` and `attributes`,
 ///       `successors` fields.
 constexpr const char *initTemplate = R"Py(
   def __init__(self, {0}):
     operands = []
-    results = []
     attributes = {{}
     regions = None
     {1}
     super().__init__(self.build_generic(
       attributes=attributes, results=results, operands=operands,
       successors=_ods_successors, regions=regions, loc=loc, ip=ip))
 )Py";
 
 /// Template for appending a single element to the operand/result list.
 ///   {0} is the field name.
 constexpr const char *singleOperandAppendTemplate =
     "operands.append(_get_op_result_or_value({0}))";
-constexpr const char *singleResultAppendTemplate = "results.append({0})";
 
 /// Template for appending an optional element to the operand/result list.
 ///   {0} is the field name.
 constexpr const char *optionalAppendOperandTemplate =
     "if {0} is not None: operands.append(_get_op_result_or_value({0}))";
 constexpr const char *optionalAppendAttrSizedOperandsTemplate =
     "operands.append(_get_op_result_or_value({0}) if {0} is not None else "
     "None)";
-constexpr const char *optionalAppendResultTemplate =
-    "if {0} is not None: results.append({0})";
 
 /// Template for appending a list of elements to the operand/result list.
 ///   {0} is the field name.
 constexpr const char *multiOperandAppendTemplate =
     "operands.extend(_get_op_results_or_values({0}))";
 constexpr const char *multiOperandAppendPackTemplate =
     "operands.append(_get_op_results_or_values({0}))";
-constexpr const char *multiResultAppendTemplate = "results.extend({0})";
 
 /// Template for setting an attribute in the operation builder.
 ///   {0} is the attribute name;
 ///   {1} is the builder argument name.
 constexpr const char *initAttributeTemplate = R"Py(attributes["{0}"] = {1})Py";
 
 /// Template for setting an optional attribute in the operation builder.
 ///   {0} is the attribute name;

 
 /// Returns true if there is a trait or interface that can be used to infer
 /// result types of the given operation.
 static bool canInferType(const Operator &op) {
   return hasSameArgumentAndResultTypes(op) ||
          hasFirstAttrDerivedResultTypes(op) || hasInferTypeInterface(op);
 }
 
-/// Populates `builderArgs` with result names if the builder is expected to
-/// accept them as arguments.
-static void
-populateBuilderArgsResults(const Operator &op,
-                           llvm::SmallVectorImpl<std::string> &builderArgs) {
-  if (canInferType(op))
-    return;
-
-  for (int i = 0, e = op.getNumResults(); i < e; ++i) {
-    std::string name = op.getResultName(i).str();
-    if (name.empty()) {
-      if (op.getNumResults() == 1) {
-        // Special case for one result, make the default name be 'result'
-        // to properly match the built-in result accessor.
-        name = "result";
-      } else {
-        name = llvm::formatv("_gen_res_{0}", i);
-      }
-    }
-    name = sanitizeName(name);
-    builderArgs.push_back(name);
-  }
-}
-
 /// Populates `builderArgs` with the Python-compatible names of builder function
 /// arguments using intermixed attributes and operands in the same order as they
 /// appear in the `arguments` field of the op definition. Additionally,
 /// `operandNames` is populated with names of operands in their order of
 /// appearance.
 static void
 populateBuilderArgs(const Operator &op,
                     llvm::SmallVectorImpl<std::string> &builderArgs,
for (int i = 0, e = op.getNumOperands(); i < e; ++i) {
     builderLines.push_back(llvm::formatv(formatString.data(), name));
   }
 }
 
 /// Python code template for deriving the operation result types from its
 /// attribute:
 ///   - {0} is the name of the attribute from which to derive the types.
 constexpr const char *deriveTypeFromAttrTemplate =
-    R"PY(_ods_result_type_source_attr = attributes["{0}"]
+    R"PY(  _ods_result_type_source_attr = attributes["{0}"]
   _ods_derived_result_type = (
     _ods_ir.TypeAttr(_ods_result_type_source_attr).value
     if _ods_ir.TypeAttr.isinstance(_ods_result_type_source_attr) else
     _ods_result_type_source_attr.type))PY";
 
 /// Python code template appending {0} type {1} times to the results list.
-constexpr const char *appendSameResultsTemplate = "results.extend([{0}] * {1})";
+constexpr const char *setSameResultsTemplate = "  results = [{0}] * {1}";
 
 /// Python code template for inferring the operation results using the
 /// corresponding interface:
 ///   - {0} is the name of the class for which the types are inferred.
 constexpr const char *inferTypeInterfaceTemplate =
-    R"PY(_ods_context = _ods_get_default_loc_context(loc)
+    R"PY(  _ods_context = _ods_get_default_loc_context(loc)
   results = _ods_ir.InferTypeOpInterface({0}).inferReturnTypes(
       operands=operands,
       attributes=_ods_ir.DictAttr.get(attributes, context=_ods_context),
       context=_ods_context,
       loc=loc)
 )PY";
 
 /// Appends the given multiline string as individual strings into
 /// `builderLines`.
 static void appendLineByLine(StringRef string,
                              llvm::SmallVectorImpl<std::string> &builderLines) {
 
   std::pair<StringRef, StringRef> split = std::make_pair(string, string);
   do {
     split = split.second.split('\n');
     builderLines.push_back(split.first.str());
   } while (!split.second.empty());
 }
 
 /// Populates `builderLines` with additional lines that are required in the
 /// builder to set up op results.
 static void
 populateBuilderLinesResult(const Operator &op,
-                           llvm::ArrayRef<std::string> names,
                            llvm::SmallVectorImpl<std::string> &builderLines) {
-  bool sizedSegments = op.getTrait(attrSizedTraitForKind("result")) != nullptr;
-
+  builderLines.push_back("if not results:");
   if (hasSameArgumentAndResultTypes(op)) {
     builderLines.push_back(llvm::formatv(
-        appendSameResultsTemplate, "operands[0].type", op.getNumResults()));
+        setSameResultsTemplate, "operands[0].type", op.getNumResults()));
     return;
   }
 
   if (hasFirstAttrDerivedResultTypes(op)) {
     const NamedAttribute &firstAttr = op.getAttribute(0);
     assert(!firstAttr.name.empty() && "unexpected empty name for the attribute "
                                       "from which the type is derived");
     appendLineByLine(
         llvm::formatv(deriveTypeFromAttrTemplate, firstAttr.name).str(),
         builderLines);
-    builderLines.push_back(llvm::formatv(appendSameResultsTemplate,
+    builderLines.push_back(llvm::formatv(setSameResultsTemplate,
                                          "_ods_derived_result_type",
                                          op.getNumResults()));
     return;
   }
 
   if (hasInferTypeInterface(op)) {
     appendLineByLine(
         llvm::formatv(inferTypeInterfaceTemplate, op.getCppClassName()).str(),
         builderLines);
     return;
   }
-
-  // For each element, find or generate a name.
-  for (int i = 0, e = op.getNumResults(); i < e; ++i) {
-    const NamedTypeConstraint &element = op.getResult(i);
-    std::string name = names[i];
-
-    // Choose the formatting string based on the element kind.
-    llvm::StringRef formatString;
-    if (!element.isVariableLength()) {
-      formatString = singleResultAppendTemplate;
-    } else if (element.isOptional()) {
-      formatString = optionalAppendResultTemplate;
-    } else {
-      assert(element.isVariadic() && "unhandled element group type");
-      // If emitting with sizedSegments, then we add the actual list-typed
-      // element. Otherwise, we extend the actual operands.
-      if (sizedSegments) {
-        formatString = singleResultAppendTemplate;
-      } else {
-        formatString = multiResultAppendTemplate;
-      }
-    }
-
-    builderLines.push_back(llvm::formatv(formatString.data(), name));
-  }
 }
 
 /// If the operation has variadic regions, adds a builder argument to specify
 /// the number of those regions and builder lines to forward it to the generic
 /// constructor.
 static void
 populateBuilderRegions(const Operator &op,
                        llvm::SmallVectorImpl<std::string> &builderArgs,
if (op.skipDefaultBuilders())
     return;
 
   llvm::SmallVector<std::string> builderArgs;
   llvm::SmallVector<std::string> builderLines;
   llvm::SmallVector<std::string> operandArgNames;
   llvm::SmallVector<std::string> successorArgNames;
   builderArgs.reserve(op.getNumOperands() + op.getNumResults() +
                       op.getNumNativeAttributes() + op.getNumSuccessors());
-  populateBuilderArgsResults(op, builderArgs);
-  size_t numResultArgs = builderArgs.size();
   populateBuilderArgs(op, builderArgs, operandArgNames, successorArgNames);
-  size_t numOperandAttrArgs = builderArgs.size() - numResultArgs;
+  size_t numOperandAttrArgs = builderArgs.size();
   populateBuilderArgsSuccessors(op, builderArgs, successorArgNames);
 
   populateBuilderLinesOperand(op, operandArgNames, builderLines);
-  populateBuilderLinesAttr(
-      op, llvm::makeArrayRef(builderArgs).drop_front(numResultArgs),
-      builderLines);
-  populateBuilderLinesResult(
-      op, llvm::makeArrayRef(builderArgs).take_front(numResultArgs),
-      builderLines);
+  populateBuilderLinesAttr(op, llvm::makeArrayRef(builderArgs), builderLines);
   populateBuilderLinesSuccessors(op, successorArgNames, builderLines);
   populateBuilderRegions(op, builderArgs, builderLines);
 
   // Layout of builderArgs vector elements:
-  // [ result_args  operand_attr_args successor_args regions ]
+  // [ operand_attr_args successor_args regions ]
 
   // Determine whether the argument corresponding to a given index into the
   // builderArgs vector is a python keyword argument or not.
   auto isKeywordArgFn = [&](size_t builderArgIndex) -> bool {
-    // All result, successor, and region arguments are positional arguments.
-    if ((builderArgIndex < numResultArgs) ||
-        (builderArgIndex >= (numResultArgs + numOperandAttrArgs)))
+    // All successor, and region arguments are positional arguments.
+    if (builderArgIndex >= numOperandAttrArgs)
       return false;
     // Keyword arguments:
     // - optional named attributes (including unit attributes)
     // - default-valued named attributes
     // - optional operands
-    Argument a = op.getArg(builderArgIndex - numResultArgs);
+    Argument a = op.getArg(builderArgIndex);
     if (auto *nattr = a.dyn_cast<NamedAttribute *>())
       return (nattr->attr.isOptional() || nattr->attr.hasDefaultValue());
     if (auto *ntype = a.dyn_cast<NamedTypeConstraint *>())
       return ntype->isOptional();
     return false;
   };
 
   // StringRefs in functionArgs refer to strings allocated by builderArgs.
static void emitDefaultOpBuilder(const Operator &op, raw_ostream &os) {
   for (size_t i = 0, cnt = builderArgs.size(); i < cnt; ++i) {
     if (isKeywordArgFn(i)) {
       builderArgs[i].append("=None");
       functionArgs.push_back(builderArgs[i]);
     }
   }
   functionArgs.push_back("loc=None");
   functionArgs.push_back("ip=None");
+
+  if (op.getNumResults()) {
+    if (canInferType(op)) {
+      builderArgs.push_back("results=[]");
+      populateBuilderLinesResult(op, builderLines);
+    } else {
+      builderArgs.push_back("results");
+    }
+    functionArgs.push_back(builderArgs.back());
+  } else {
+    builderLines.push_back("results = []");
+  }
+
   os << llvm::formatv(initTemplate, llvm::join(functionArgs, ", "),
                       llvm::join(builderLines, "\n    "));
 }
 
 static void constructAttributeMapping(const llvm::RecordKeeper &records,
                                       AttributeClasses &attributeClasses) {
   for (const llvm::Record *rec :
        records.getAllDerivedDefinitions("PythonAttr")) {