[mlir][Python] Roll up of python API fixes.

[stellaraccident]

Summary

• As discussed, fixes the ordering or (operands, results) -> (results, operands) in various create like methods.
• Fixes a syntax error in an ODS accessor method.
• Removes the linalg example in favor of a test case that exercises the same.
• Fixes FuncOp visibility to properly use None instead of the empty string and defaults it to None.
• Implements what was documented for requiring that trailing init args loc and ip are keyword only.
• Adds a check to InsertionPoint.insert so that if attempting to insert past the terminator, an exception is raised telling you what to do instead. Previously, this would crash downstream (i.e. when trying to print the resultant module).
• Renames _ods_build_default -> build_generic and documents it.
• Removes result from the list of prohibited words and for single-result ops, defaults to naming the result result, thereby matching expectations and what is already implemented on the base class.
• This was intended to be a relatively small set of changes to be inlined with the broader support for ODS generating the most specific builder, but it spidered out once actually testing various combinations, so rolling up separately.

[mehdi_amini]

mlir/lib/Bindings/Python/IRModules.cpp

1369

Nice error message! I love it when we can suggest a corrective alternative to users :)

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

646

What is the named star arguments used for here? Can you document this here? (and maybe somewhere else, in the .md doc?)

[stellaraccident]

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

646

It's just python syntax for terminating the positional argument part of the declaration. It's been around for a long time but the long Python2 phase-out means that a lot of people are just discovering that it is a thing: https://www.python.org/dev/peps/pep-3102/

Given that this is just a language feature, I'm inclined to not comment further. The doc (md file) do call this out as keyword only arguments.

[jpienaar]

Nice, thanks! (couple of questions, apologies if already discussed)

mlir/docs/Bindings/Python.md

457

Q: how frequent is this used via this vs via InsertionPoint? I was wondering if we called this insertion_point where we'd fall on the verbosity/self-documenting spectrum? (it may be bias but loc == location is a pretty standard abbreviation while ip is a bit new for me)

mlir/test/Bindings/Python/dialects/linalg.py

25

So the insertion point is at the end of the block and so all insertions are at end of block? (I was just thinking: what would it mean if we had an existing block and we set the position to the start of that block? If every instruction gets the same insertion point, would it result in an inversion in the ir of the ops inserted?). Being nitty here :) But just trying to think of what the insertion point context means here, C++ side I understand you set the position and then all additions follow post, so I have a mental model of a linear list of ops being, while in this interface it almost feels like I have a "fixed" insertion point used by all creates.

27

OOC: Would it be possible to not require .result? E.g., implicit cast from op to result if op has single result? Or like op[n] is nth output? (where nth == ODS returns, so could be variadic too). Or would that be more something layered on top of this?

[stellaraccident]

mlir/docs/Bindings/Python.md

457

I've found that there are two styles of use of these APIs:

• Humans writing scripts to construct IR: Tends to use context managers with implicit context, location and insertion point a lot (most of our tests are written in this style).
• Python and/or DSL compilers that are constructing IR from some form of AST: tend to use explicit loc and ip because it is better to be explicit and not have spooky action at a distance things going on. Npcomp uses this style a lot, and ip is quite frequent. It is a lot less typing and long line wrapping to abbreviate it in those contexts (which tend to have a lot of long lines anyway).

mlir/test/Bindings/Python/dialects/linalg.py

25

I went back and forth on this a bunch when trying to come up with what we have, but happy to be nitty about it.

In this API, which follows the C-API convention, the InsertionPoint always inserts before a reference operation, with a None interpreted as the operation one-past-the-end of the Block. When constructing it you have these options:

• InsertionPoint(ref_op): Insert before the given ref op (interpreting None as insert at end of block).
• InsertionPoint.at_block_begin(block): If the block is not empty, same as InsertionPoint(block.operations[0]), otherwise, same as InsertionPoint(None).
• InsertionPoint.at_block_terminator(block): Inserts before the terminator of the block, raising an error if the block is empty or if the last operation is not a known terminator.

See the insertion_point.py test for some samples of the different orderings.

I think this is actually how the C++ side OpBuilder::InsertPoint functions as well, no? The difference is that since it uses a C++ iterator, it is directly expressible to represent the operation-one-past-the-last, whereas we represent that as None on the Python side.

27

Yes, I think I've mentioned this before but it was before most people could see/use e2e examples enough to have an opinion. Not having this implicit "cast" is probably the single biggest source of typos I made in npcomp. Given that Python typing is already... loose... I wanted to have a pretty good body of work before loosening it further in that way. But I think we are there now, and a cast extension on the Operation.create related functions could make this just work.

mlir/docs/Bindings/Python.md

 * `_ODS_OPERAND_SEGMENTS` and `_ODS_RESULT_SEGMENTS`: Black-box value which
   indicates the structure of either the operand or results with respect to
   variadics. Used by `OpView._ods_build_default` to decode operand and result
   lists that contain lists.
 
 #### Builders
 
 Presently, only a single, default builder is mapped to the `__init__` method.
-Generalizing this facility is under active development. It currently accepts
-arguments:
+The intent is that this `__init__` method represents the *most specific* of
+the builders typically generated for C++; however currently it is just the
+generic form below.
 
 * One argument for each declared result:
   * For single-valued results: Each will accept an `mlir.ir.Type`.
   * For variadic results: Each will accept a `List[mlir.ir.Type]`.
 * One argument for each declared operand or attribute:
   * For single-valued operands: Each will accept an `mlir.ir.Value`.
   * For variadic operands: Each will accept a `List[mlir.ir.Value]`.
   * For attributes, it will accept an `mlir.ir.Attribute`.
 * Trailing usage-specific, optional keyword arguments:
   * `loc`: An explicit `mlir.ir.Location` to use. Defaults to the location
     bound to the thread (i.e. `with Location.unknown():`) or an error if none
     is bound nor specified.
-  * `context`: An explicit `mlir.ir.Context` to use. Default to the context
-    bound to the thread (i.e. `with Context():` or implicitly via `Location` or
-    `InsertionPoint` context managers) or an error if none is bound nor
-    specified.
+  * `ip`: An explicit `mlir.ir.InsertionPoint` to use. Default to the insertion
+    point bound to the thread (i.e. `with InsertionPoint(...):`).
+
+In addition, each `OpView` inherits a `build_generic` method which allows
+construction via a (nested in the case of variadic) sequence of `results` and
+`operands`. This can be used to get some default construction semantics for
+operations that are otherwise unsupported in Python, at the expense of having
+a very generic signature.

mlir/examples/python/.style.yapf

-[style]
-  based_on_style = google
-  column_limit = 80
-  indent_width = 2

mlir/examples/python/linalg_matmul.py

-#  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-#  See https://llvm.org/LICENSE.txt for license information.
-#  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-# This is a work in progress example to do end2end build and code generation
-# of a small linalg program with configuration options. It is currently non
-# functional and is being used to elaborate the APIs.
-
-from typing import Tuple
-
-from mlir.ir import *
-from mlir.dialects import linalg
-from mlir.dialects import std
-
-
-# TODO: This should be in the core API.
-def FuncOp(name: str, func_type: Type) -> Tuple[Operation, Block]:
-  """Creates a |func| op.
-    TODO: This should really be in the MLIR API.
-    Returns:
-      (operation, entry_block)
-    """
-  attrs = {
-      "type": TypeAttr.get(func_type),
-      "sym_name": StringAttr.get(name),
-  }
-  op = Operation.create("func", regions=1, attributes=attrs)
-  body_region = op.regions[0]
-  entry_block = body_region.blocks.append(*func_type.inputs)
-  return op, entry_block
-
-
-def build_matmul_buffers_func(func_name, m, k, n, dtype):
-  lhs_type = MemRefType.get([m, k], dtype)
-  rhs_type = MemRefType.get([k, n], dtype)
-  result_type = MemRefType.get([m, n], dtype)
-  # TODO: There should be a one-liner for this.
-  func_type = FunctionType.get([lhs_type, rhs_type, result_type], [])
-  _, entry = FuncOp(func_name, func_type)
-  lhs, rhs, result = entry.arguments
-  with InsertionPoint(entry):
-    op = linalg.MatmulOp([lhs, rhs], [result])
-    # TODO: Implement support for SingleBlockImplicitTerminator
-    block = op.regions[0].blocks.append()
-    with InsertionPoint(block):
-        linalg.YieldOp(values=[])
-
-    std.ReturnOp([])
-
-
-def build_matmul_tensors_func(func_name, m, k, n, dtype):
-  lhs_type = RankedTensorType.get([m, k], dtype)
-  rhs_type = RankedTensorType.get([k, n], dtype)
-  result_type = RankedTensorType.get([m, n], dtype)
-  # TODO: There should be a one-liner for this.
-  func_type = FunctionType.get([lhs_type, rhs_type], [result_type])
-  _, entry = FuncOp(func_name, func_type)
-  lhs, rhs = entry.arguments
-  with InsertionPoint(entry):
-    op = linalg.MatmulOp([lhs, rhs], results=[result_type])
-    # TODO: Implement support for SingleBlockImplicitTerminator
-    block = op.regions[0].blocks.append()
-    with InsertionPoint(block):
-        linalg.YieldOp(values=[])
-    std.ReturnOp([op.result])
-
-
-def run():
-  with Context() as c, Location.unknown():
-    module = Module.create()
-    # TODO: This at_block_terminator vs default construct distinction feels
-    # wrong and is error-prone.
-    with InsertionPoint.at_block_terminator(module.body):
-      build_matmul_buffers_func('main_buffers', 18, 32, 96, F32Type.get())
-      build_matmul_tensors_func('main_tensors', 18, 32, 96, F32Type.get())
-
-    print(module)
-
-
-if __name__ == '__main__':
-  run()

mlir/lib/Bindings/Python/IRModules.h

public:
   PyBlock getBlock();
 
   /// Gets the parent operation or raises an exception if the operation has
   /// no parent.
   PyOperationRef getParentOperation();
 
   /// Creates an operation. See corresponding python docstring.
   static pybind11::object
-  create(std::string name, llvm::Optional<std::vector<PyValue *>> operands,
-         llvm::Optional<std::vector<PyType *>> results,
+  create(std::string name, llvm::Optional<std::vector<PyType *>> results,
+         llvm::Optional<std::vector<PyValue *>> operands,
          llvm::Optional<pybind11::dict> attributes,
          llvm::Optional<std::vector<PyBlock *>> successors, int regions,
          DefaultingPyLocation location, pybind11::object ip);
 
   /// Creates an OpView suitable for this operation.
   pybind11::object createOpView();
 
 private:
public:
   PyOpView(pybind11::object operationObject);
   PyOperation &getOperation() override { return operation; }
 
   static pybind11::object createRawSubclass(pybind11::object userClass);
 
   pybind11::object getOperationObject() { return operationObject; }
 
   static pybind11::object
-  odsBuildDefault(pybind11::object cls, pybind11::list operandList,
-                  pybind11::list resultTypeList,
-                  llvm::Optional<pybind11::dict> attributes,
-                  llvm::Optional<std::vector<PyBlock *>> successors,
-                  llvm::Optional<int> regions, DefaultingPyLocation location,
-                  pybind11::object maybeIp);
+  buildGeneric(pybind11::object cls, pybind11::list resultTypeList,
+               pybind11::list operandList,
 
 private:
   PyOperation &operation;           // For efficient, cast-free access from C++
   pybind11::object operationObject; // Holds the reference.
 };
 
 /// Wrapper around an MlirRegion.
 /// Regions are managed completely by their containing operation. Unlike the

mlir/lib/Bindings/Python/IRModules.cpp

 PyBlock PyOperation::getBlock() {
   PyOperationRef parentOperation = getParentOperation();
   MlirBlock block = mlirOperationGetBlock(get());
   assert(!mlirBlockIsNull(block) && "Attached operation has null parent");
   return PyBlock{std::move(parentOperation), block};
 }
 
 py::object PyOperation::create(
-    std::string name, llvm::Optional<std::vector<PyValue *>> operands,
-    llvm::Optional<std::vector<PyType *>> results,
+    std::string name, llvm::Optional<std::vector<PyType *>> results,
+    llvm::Optional<std::vector<PyValue *>> operands,
     llvm::Optional<py::dict> attributes,
     llvm::Optional<std::vector<PyBlock *>> successors, int regions,
     DefaultingPyLocation location, py::object maybeIp) {
   llvm::SmallVector<MlirValue, 4> mlirOperands;
   llvm::SmallVector<MlirType, 4> mlirResults;
   llvm::SmallVector<MlirBlock, 4> mlirSuccessors;
   llvm::SmallVector<std::pair<std::string, MlirAttribute>, 4> mlirAttributes;
 
py::object PyOperation::createOpView() {
   return py::cast(PyOpView(getRef().getObject()));
 }
 
 //------------------------------------------------------------------------------
 // PyOpView
 //------------------------------------------------------------------------------
 
 py::object
-PyOpView::odsBuildDefault(py::object cls, py::list operandList,
-                          py::list resultTypeList,
-                          llvm::Optional<py::dict> attributes,
-                          llvm::Optional<std::vector<PyBlock *>> successors,
-                          llvm::Optional<int> regions,
-                          DefaultingPyLocation location, py::object maybeIp) {
+PyOpView::buildGeneric(py::object cls, py::list resultTypeList,
+                       py::list operandList,
   PyMlirContextRef context = location->getContext();
   // Class level operation construction metadata.
   std::string name = py::cast<std::string>(cls.attr("OPERATION_NAME"));
   // Operand and result segment specs are either none, which does no
   // variadic unpacking, or a list of ints with segment sizes, where each
   // element is either a positive number (typically 1 for a scalar) or -1 to
   // indicate that it is derived from the length of the same-indexed operand
   // or result (implying that it is a list at that position).
if (!operandSegmentLengths.empty()) {
           mlirVectorTypeGet(1, &size, mlirIntegerTypeGet(context->get(), 64)),
           operandSegmentLengths.size(), operandSegmentLengths.data());
       (*attributes)["operand_segment_sizes"] =
           PyAttribute(context, segmentLengthAttr);
     }
   }
 
   // Delegate to create.
-  return PyOperation::create(std::move(name), /*operands=*/std::move(operands),
+  return PyOperation::create(std::move(name),
                              /*results=*/std::move(resultTypes),
+                             /*operands=*/std::move(operands),
                              /*attributes=*/std::move(attributes),
                              /*successors=*/std::move(successors),
                              /*regions=*/*regions, location, maybeIp);
 }
 
 PyOpView::PyOpView(py::object operationObject)
     // Casting through the PyOperationBase base-class and then back to the
     // Operation lets us accept any PyOperationBase subclass.
if (operation.isAttached())
     throw SetPyError(PyExc_ValueError,
                      "Attempt to insert operation that is already attached");
   block.getParentOperation()->checkValid();
   MlirOperation beforeOp = {nullptr};
   if (refOperation) {
     // Insert before operation.
     (*refOperation)->checkValid();
     beforeOp = (*refOperation)->get();
+  } else {
+    // Insert at end (before null) is only valid if the block does not
+    // already end in a known terminator (violating this will cause assertion
+    // failures later).
+    if (!mlirOperationIsNull(mlirBlockGetTerminator(block.get()))) {
+      throw py::index_error("Cannot insert operation at the end of a block "
+                            "that already has a terminator. Did you mean to "
+                            "use 'InsertionPoint.at_block_terminator(block)' "
+                            "versus 'InsertionPoint(block)'?");
+    }
   }
   mlirBlockInsertOwnedOperationBefore(block.get(), beforeOp, operation);
   operation.setAttached();
 }
 
 PyInsertionPoint PyInsertionPoint::atBlockBegin(PyBlock &block) {
   MlirOperation firstOp = mlirBlockGetFirstOperation(block.get());
   if (mlirOperationIsNull(firstOp)) {
py::class_<PyOperationBase>(m, "_OperationBase")
           [](PyOperationBase &self) {
             return mlirOperationVerify(self.getOperation());
           },
           "Verify the operation and return true if it passes, false if it "
           "fails.");
 
   py::class_<PyOperation, PyOperationBase>(m, "Operation")
       .def_static("create", &PyOperation::create, py::arg("name"),
-                  py::arg("operands") = py::none(),
                   py::arg("results") = py::none(),
+                  py::arg("operands") = py::none(),
                   py::arg("attributes") = py::none(),
                   py::arg("successors") = py::none(), py::arg("regions") = 0,
                   py::arg("loc") = py::none(), py::arg("ip") = py::none(),
                   kOperationCreateDocstring)
       .def_property_readonly("name",
                              [](PyOperation &self) {
                                MlirOperation operation = self.get();
                                MlirStringRef name = mlirIdentifierStr(
auto opViewClass =
               },
               "Context that owns the Operation")
           .def("__str__", [](PyOpView &self) {
             return py::str(self.getOperationObject());
           });
   opViewClass.attr("_ODS_REGIONS") = py::make_tuple(0, true);
   opViewClass.attr("_ODS_OPERAND_SEGMENTS") = py::none();
   opViewClass.attr("_ODS_RESULT_SEGMENTS") = py::none();
-  opViewClass.attr("_ods_build_default") = classmethod(
-      &PyOpView::odsBuildDefault, py::arg("cls"),
-      py::arg("operands") = py::none(), py::arg("results") = py::none(),
-      py::arg("attributes") = py::none(), py::arg("successors") = py::none(),
-      py::arg("regions") = py::none(), py::arg("loc") = py::none(),
-      py::arg("ip") = py::none(),
+  opViewClass.attr("build_generic") = classmethod(
+      &PyOpView::buildGeneric, py::arg("cls"), py::arg("results") = py::none(),
+      py::arg("operands") = py::none(), py::arg("attributes") = py::none(),
+      py::arg("successors") = py::none(), py::arg("regions") = py::none(),
+      py::arg("loc") = py::none(), py::arg("ip") = py::none(),
       "Builds a specific, generated OpView based on class level attributes.");
 
   //----------------------------------------------------------------------------
   // Mapping of PyRegion.
   //----------------------------------------------------------------------------
   py::class_<PyRegion>(m, "Region")
       .def_property_readonly(
           "blocks",

mlir/lib/Bindings/Python/mlir/dialects/_builtin.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 from mlir.ir import *
 
 
 class ModuleOp:
   """Specialization for the module op class."""
 
-  def __init__(self, loc=None, ip=None):
+  def __init__(self, *, loc=None, ip=None):
     super().__init__(
-        self._ods_build_default(operands=[], results=[], loc=loc, ip=ip))
+        self.build_generic(results=[], operands=[], loc=loc, ip=ip))
     body = self.regions[0].blocks.append()
     with InsertionPoint(body):
       Operation.create("module_terminator")
 
   @property
   def body(self):
     return self.regions[0].blocks[0]
 
 
 class FuncOp:
   """Specialization for the func op class."""
 
   def __init__(self,
                name,
                type,
-               visibility,
+               *,
+               visibility=None,
                body_builder=None,
                loc=None,
                ip=None):
     """
     Create a FuncOp with the provided `name`, `type`, and `visibility`.
     - `name` is a string representing the function name.
     - `type` is either a FunctionType or a pair of list describing inputs and
       results.
-    - `visibility` is a string matching `public`, `private`, or `nested`. The
-      empty string implies a private visibility.
+    - `visibility` is a string matching `public`, `private`, or `nested`. None
+      implies private visibility.
     - `body_builder` is an optional callback, when provided a new entry block
       is created and the callback is invoked with the new op as argument within
       an InsertionPoint context already set for the block. The callback is
       expected to insert a terminator in the block.
     """
     sym_name = StringAttr.get(str(name))
 
     # If the type is passed as a tuple, build a FunctionType on the fly.
     if isinstance(type, tuple):
       type = FunctionType.get(inputs=type[0], results=type[1])
 
     type = TypeAttr.get(type)
     sym_visibility = StringAttr.get(
         str(visibility)) if visibility is not None else None
-    super().__init__(sym_name, type, sym_visibility, loc, ip)
+    super().__init__(sym_name, type, sym_visibility, loc=loc, ip=ip)
     if body_builder:
       entry_block = self.add_entry_block()
       with InsertionPoint(entry_block):
         body_builder(self)
 
   @property
   def is_external(self):
     return len(self.regions[0].blocks) == 0

mlir/lib/Bindings/Python/mlir/dialects/_linalg.py

 #  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 #  See https://llvm.org/LICENSE.txt for license information.
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 
 class StructuredOpMixin:
   """All structured ops use the same mixin class."""
 
   def __init__(self, inputs, outputs=(), results=(), loc=None, ip=None):
     if outputs and results:
       raise ValueError(
           "Structured ops must have outputs or results, but not both.")
     super().__init__(
-        self._ods_build_default(operands=[list(inputs),
-                                          list(outputs)],
-                                results=list(results),
-                                loc=loc,
-                                ip=ip))
+        self.build_generic(results=list(results),
+                           operands=[list(inputs), list(outputs)],
 
 
 def select_opview_mixin(parent_opview_cls):
   # TODO: This shouldn't be a heuristic: we should have a way to annotate
   # the OpView to note that it is a structured op.
   if ("__init__" not in parent_opview_cls.__dict__ and
       hasattr(parent_opview_cls, "inputs") and
       hasattr(parent_opview_cls, "outputs") and
       hasattr(parent_opview_cls, "result_tensors")):
     return StructuredOpMixin

mlir/test/Bindings/Python/dialects/linalg.py

+# RUN: %PYTHON %s | FileCheck %s
+
+from mlir.ir import *
+from mlir.dialects import builtin
+from mlir.dialects import linalg
+from mlir.dialects import std
+
+
+def run(f):
+  print("\nTEST:", f.__name__)
+  f()
+
+
+# CHECK-LABEL: TEST: testStructuredOpOnTensors
+def testStructuredOpOnTensors():
+  with Context() as ctx, Location.unknown():
+    module = Module.create()
+    f32 = F32Type.get()
+    tensor_type = RankedTensorType.get((2, 3, 4), f32)
+    with InsertionPoint.at_block_terminator(module.body):
+      func = builtin.FuncOp(name="matmul_test",
+                            type=FunctionType.get(
+                                inputs=[tensor_type, tensor_type],
+                                results=[tensor_type]))
+      with InsertionPoint(func.add_entry_block()):
+        lhs, rhs = func.entry_block.arguments
+        result = linalg.MatmulOp([lhs, rhs], results=[tensor_type]).result
+        std.ReturnOp([result])
+
+  # CHECK: %[[R:.*]] = linalg.matmul ins(%arg0, %arg1 : tensor<2x3x4xf32>, tensor<2x3x4xf32>) -> tensor<2x3x4xf32>
+  print(module)
+
+
+run(testStructuredOpOnTensors)
+
+
+# CHECK-LABEL: TEST: testStructuredOpOnBuffers
+def testStructuredOpOnBuffers():
+  with Context() as ctx, Location.unknown():
+    module = Module.create()
+    f32 = F32Type.get()
+    memref_type = MemRefType.get((2, 3, 4), f32)
+    with InsertionPoint.at_block_terminator(module.body):
+      func = builtin.FuncOp(name="matmul_test",
+                            type=FunctionType.get(
+                                inputs=[memref_type, memref_type, memref_type],
+                                results=[]))
+      with InsertionPoint(func.add_entry_block()):
+        lhs, rhs, result = func.entry_block.arguments
+        linalg.MatmulOp([lhs, rhs], outputs=[result])
+        std.ReturnOp([])
+
+  # CHECK: linalg.matmul ins(%arg0, %arg1 : memref<2x3x4xf32>, memref<2x3x4xf32>) outs(%arg2 : memref<2x3x4xf32>)
+  print(module)
+
+
+run(testStructuredOpOnBuffers)

mlir/test/Bindings/Python/insertion_point.py

except ValueError as e:
       # CHECK: Block has no terminator
       print(e)
     else:
       assert False, "Expected exception"
 
 run(test_insert_at_block_terminator_missing)
 
 
+# CHECK-LABEL: TEST: test_insert_at_end_with_terminator_errors
+def test_insert_at_end_with_terminator_errors():
+  with Context() as ctx, Location.unknown():
+    ctx.allow_unregistered_dialects = True
+    m = Module.create()  # Module is created with a terminator.
+    with InsertionPoint(m.body):
+      try:
+        Operation.create("custom.op1", results=[], operands=[])
+      except IndexError as e:
+        # CHECK: ERROR: Cannot insert operation at the end of a block that already has a terminator.
+        print(f"ERROR: {e}")
+
+run(test_insert_at_end_with_terminator_errors)
+
+
 # CHECK-LABEL: TEST: test_insertion_point_context
 def test_insertion_point_context():
   ctx = Context()
   ctx.allow_unregistered_dialects = True
   with Location.unknown(ctx):
     module = Module.parse(r"""
       func @foo() -> () {
         "custom.op1"() : () -> ()

mlir/test/Bindings/Python/ods_helpers.py

def testOdsBuildDefaultImplicitRegions():
   class TestVariadicRegionsOp(OpView):
     OPERATION_NAME = "custom.test_any_regions_op"
     _ODS_REGIONS = (2, False)
 
   with Context() as ctx, Location.unknown():
     ctx.allow_unregistered_dialects = True
     m = Module.create()
     with InsertionPoint.at_block_terminator(m.body):
-      op = TestFixedRegionsOp._ods_build_default(operands=[], results=[])
+      op = TestFixedRegionsOp.build_generic(results=[], operands=[])
       # CHECK: NUM_REGIONS: 2
       print(f"NUM_REGIONS: {len(op.regions)}")
       # Including a regions= that matches should be fine.
-      op = TestFixedRegionsOp._ods_build_default(operands=[], results=[], regions=2)
+      op = TestFixedRegionsOp.build_generic(results=[], operands=[], regions=2)
       print(f"NUM_REGIONS: {len(op.regions)}")
       # Reject greater than.
       try:
-        op = TestFixedRegionsOp._ods_build_default(operands=[], results=[], regions=3)
+        op = TestFixedRegionsOp.build_generic(results=[], operands=[], regions=3)
       except ValueError as e:
         # CHECK: ERROR:Operation "custom.test_op" requires a maximum of 2 regions but was built with regions=3
         print(f"ERROR:{e}")
       # Reject less than.
       try:
-        op = TestFixedRegionsOp._ods_build_default(operands=[], results=[], regions=1)
+        op = TestFixedRegionsOp.build_generic(results=[], operands=[], regions=1)
       except ValueError as e:
         # CHECK: ERROR:Operation "custom.test_op" requires a minimum of 2 regions but was built with regions=1
         print(f"ERROR:{e}")
 
       # If no regions specified for a variadic region op, build the minimum.
-      op = TestVariadicRegionsOp._ods_build_default(operands=[], results=[])
+      op = TestVariadicRegionsOp.build_generic(results=[], operands=[])
       # CHECK: DEFAULT_NUM_REGIONS: 2
       print(f"DEFAULT_NUM_REGIONS: {len(op.regions)}")
       # Should also accept an explicit regions= that matches the minimum.
-      op = TestVariadicRegionsOp._ods_build_default(
-          operands=[], results=[], regions=2)
+      op = TestVariadicRegionsOp.build_generic(
+          results=[], operands=[], regions=2)
       # CHECK: EQ_NUM_REGIONS: 2
       print(f"EQ_NUM_REGIONS: {len(op.regions)}")
       # And accept greater than minimum.
       # Should also accept an explicit regions= that matches the minimum.
-      op = TestVariadicRegionsOp._ods_build_default(
-          operands=[], results=[], regions=3)
+      op = TestVariadicRegionsOp.build_generic(
+          results=[], operands=[], regions=3)
       # CHECK: GT_NUM_REGIONS: 3
       print(f"GT_NUM_REGIONS: {len(op.regions)}")
       # Should reject less than minimum.
       try:
-        op = TestVariadicRegionsOp._ods_build_default(operands=[], results=[], regions=1)
+        op = TestVariadicRegionsOp.build_generic(results=[], operands=[], regions=1)
       except ValueError as e:
         # CHECK: ERROR:Operation "custom.test_any_regions_op" requires a minimum of 2 regions but was built with regions=1
         print(f"ERROR:{e}")
 
 
 
 run(testOdsBuildDefaultImplicitRegions)
 
 
 def testOdsBuildDefaultNonVariadic():
 
   class TestOp(OpView):
     OPERATION_NAME = "custom.test_op"
 
   with Context() as ctx, Location.unknown():
     ctx.allow_unregistered_dialects = True
     m = Module.create()
     with InsertionPoint.at_block_terminator(m.body):
       v0 = add_dummy_value()
       v1 = add_dummy_value()
       t0 = IntegerType.get_signless(8)
       t1 = IntegerType.get_signless(16)
-      op = TestOp._ods_build_default(operands=[v0, v1], results=[t0, t1])
+      op = TestOp.build_generic(results=[t0, t1], operands=[v0, v1])
       # CHECK: %[[V0:.+]] = "custom.value"
       # CHECK: %[[V1:.+]] = "custom.value"
       # CHECK: "custom.test_op"(%[[V0]], %[[V1]])
       # CHECK-NOT: operand_segment_sizes
       # CHECK-NOT: result_segment_sizes
       # CHECK-SAME: : (i32, i32) -> (i8, i16)
       print(m)
 
with InsertionPoint.at_block_terminator(m.body):
       # CHECK: %[[V0:.+]] = "custom.value"
       # CHECK: %[[V1:.+]] = "custom.value"
       # CHECK: %[[V2:.+]] = "custom.value"
       # CHECK: %[[V3:.+]] = "custom.value"
       # CHECK: "custom.test_op"(%[[V0]], %[[V1]], %[[V2]], %[[V3]])
       # CHECK-SAME: operand_segment_sizes = dense<[1, 2, 1]> : vector<3xi64>
       # CHECK-SAME: result_segment_sizes = dense<[2, 1, 1]> : vector<3xi64>
       # CHECK-SAME: : (i32, i32, i32, i32) -> (i8, i16, i32, i64)
-      op = TestOp._ods_build_default(
-          operands=[v0, [v1, v2], v3],
-          results=[[t0, t1], t2, t3])
+      op = TestOp.build_generic(
+          results=[[t0, t1], t2, t3],
+          operands=[v0, [v1, v2], v3])
 
       # Now test with optional omitted.
       # CHECK: "custom.test_op"(%[[V0]])
       # CHECK-SAME: operand_segment_sizes = dense<[1, 0, 0]>
       # CHECK-SAME: result_segment_sizes = dense<[0, 0, 1]>
       # CHECK-SAME: (i32) -> i64
-      op = TestOp._ods_build_default(
-          operands=[v0, None, None],
-          results=[None, None, t3])
+      op = TestOp.build_generic(
+          results=[None, None, t3],
+          operands=[v0, None, None])
       print(m)
 
       # And verify that errors are raised for None in a required operand.
       try:
-        op = TestOp._ods_build_default(
-            operands=[None, None, None],
-            results=[None, None, t3])
+        op = TestOp.build_generic(
+            results=[None, None, t3],
+            operands=[None, None, None])
       except ValueError as e:
         # CHECK: OPERAND_CAST_ERROR:Operand 0 of operation "custom.test_op" must be a Value (was None and operand is not optional)
         print(f"OPERAND_CAST_ERROR:{e}")
 
       # And verify that errors are raised for None in a required result.
       try:
-        op = TestOp._ods_build_default(
-            operands=[v0, None, None],
-            results=[None, None, None])
+        op = TestOp.build_generic(
+            results=[None, None, None],
+            operands=[v0, None, None])
       except ValueError as e:
         # CHECK: RESULT_CAST_ERROR:Result 2 of operation "custom.test_op" must be a Type (was None and result is not optional)
         print(f"RESULT_CAST_ERROR:{e}")
 
       # Variadic lists with None elements should reject.
       try:
-        op = TestOp._ods_build_default(
-            operands=[v0, [None], None],
-            results=[None, None, t3])
+        op = TestOp.build_generic(
+            results=[None, None, t3],
+            operands=[v0, [None], None])
       except ValueError as e:
         # CHECK: OPERAND_LIST_CAST_ERROR:Operand 1 of operation "custom.test_op" must be a Sequence of Values (contained a None item)
         print(f"OPERAND_LIST_CAST_ERROR:{e}")
       try:
-        op = TestOp._ods_build_default(
-            operands=[v0, None, None],
-            results=[[None], None, t3])
+        op = TestOp.build_generic(
+            results=[[None], None, t3],
+            operands=[v0, None, None])
       except ValueError as e:
         # CHECK: RESULT_LIST_CAST_ERROR:Result 0 of operation "custom.test_op" must be a Sequence of Types (contained a None item)
         print(f"RESULT_LIST_CAST_ERROR:{e}")
 
 run(testOdsBuildDefaultSizedVariadic)
 
 
 def testOdsBuildDefaultCastError():
 
   class TestOp(OpView):
     OPERATION_NAME = "custom.test_op"
 
   with Context() as ctx, Location.unknown():
     ctx.allow_unregistered_dialects = True
     m = Module.create()
     with InsertionPoint.at_block_terminator(m.body):
       v0 = add_dummy_value()
       v1 = add_dummy_value()
       t0 = IntegerType.get_signless(8)
       t1 = IntegerType.get_signless(16)
       try:
-        op = TestOp._ods_build_default(
-            operands=[None, v1],
-            results=[t0, t1])
+        op = TestOp.build_generic(
+            results=[t0, t1],
+            operands=[None, v1])
       except ValueError as e:
         # CHECK: ERROR: Operand 0 of operation "custom.test_op" must be a Value
         print(f"ERROR: {e}")
       try:
-        op = TestOp._ods_build_default(
-            operands=[v0, v1],
-            results=[t0, None])
+        op = TestOp.build_generic(
+            results=[t0, None],
+            operands=[v0, v1])
       except ValueError as e:
         # CHECK: Result 1 of operation "custom.test_op" must be a Type
         print(f"ERROR: {e}")
 
 run(testOdsBuildDefaultCastError)

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

class TestOp<string mnemonic, list<OpTrait> traits = []> :
     Op<Test_Dialect, mnemonic, traits>;
 
 // 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,-1,]
 def AttrSizedOperandsOp : TestOp<"attr_sized_operands",
                                  [AttrSizedOperandSegments]> {
-  // CHECK: def __init__(self, variadic1, non_variadic, variadic2, loc=None, ip=None):
+  // CHECK: def __init__(self, variadic1, non_variadic, variadic2, *, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   operands.append(variadic1)
   // CHECK:   operands.append(non_variadic)
   // CHECK:   if variadic2 is not None: operands.append(variadic2)
-  // CHECK:   super().__init__(self._ods_build_default(
-  // CHECK:     attributes=attributes, operands=operands, results=results,
+  // CHECK:   super().__init__(self.build_generic(
+  // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def variadic1(self):
   // CHECK:   operand_range = _ods_segmented_accessor(
   // CHECK:       self.operation.operands,
   // CHECK:       self.operation.attributes["operand_segment_sizes"], 0)
   // CHECK:   return operand_range

 }
 
 // CHECK: @_ods_cext.register_operation(_Dialect)
 // CHECK: class AttrSizedResultsOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.attr_sized_results"
 // CHECK: _ODS_RESULT_SEGMENTS = [-1,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, variadic1, non_variadic, variadic2, *, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   if variadic1 is not None: results.append(variadic1)
   // CHECK:   results.append(non_variadic)
   // CHECK:   if variadic2 is not None: results.append(variadic2)
-  // CHECK:   super().__init__(self._ods_build_default(
-  // CHECK:     attributes=attributes, operands=operands, results=results,
+  // CHECK:   super().__init__(self.build_generic(
+  // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def variadic1(self):
   // CHECK:   result_range = _ods_segmented_accessor(
   // CHECK:       self.operation.results,
   // CHECK:       self.operation.attributes["result_segment_sizes"], 0)
   // CHECK:   return result_range[0] if len(result_range) > 0 else None

 
 
 // 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, optionalF32Attr, unitAttr, in_, loc=None, ip=None):
+  // CHECK: def __init__(self, i32attr, optionalF32Attr, unitAttr, in_, *, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // 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:   super().__init__(self._ods_build_default(
-  // CHECK:     attributes=attributes, operands=operands, results=results,
+  // CHECK:   super().__init__(self.build_generic(
+  // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def i32attr(self):
   // CHECK:   return _ods_ir.IntegerAttr(self.operation.attributes["i32attr"])
 
   // CHECK: @property
   // CHECK: def optionalF32Attr(self):

 }
 
 // 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, in_, _gen_arg_2, is_, loc=None, ip=None):
+  // CHECK: def __init__(self, _gen_arg_0, in_, _gen_arg_2, is_, *, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   operands.append(_gen_arg_0)
   // CHECK:   operands.append(_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:   super().__init__(self._ods_build_default(
-  // CHECK:     attributes=attributes, operands=operands, results=results,
+  // CHECK:   super().__init__(self.build_generic(
+  // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def in_(self):
   // CHECK:   return "in" in self.operation.attributes
 
   // CHECK: @property
   // CHECK: def is_(self):
   // CHECK:   if "is" not in self.operation.attributes:
   // CHECK:     return None
   // CHECK:   return _ods_ir.FloatAttr(self.operation.attributes["is"])
   let arguments = (ins I32, UnitAttr:$in, F32, OptionalAttr<F32Attr>:$is);
 }
 
 
 // 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: def __init__(self, *, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
-  // CHECK:   super().__init__(self._ods_build_default(
-  // CHECK:     attributes=attributes, operands=operands, results=results,
+  // CHECK:   super().__init__(self.build_generic(
+  // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     loc=loc, ip=ip))
 
 // 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, i32, _gen_res_1, i64, _gen_arg_0, f32, _gen_arg_2, *, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   results.append(i32)
   // CHECK:   results.append(_gen_res_1)
   // CHECK:   results.append(i64)
   // CHECK:   operands.append(_gen_arg_0)
   // CHECK:   operands.append(f32)
   // CHECK:   operands.append(_gen_arg_2)
-  // CHECK:   super().__init__(self._ods_build_default(
-  // CHECK:     attributes=attributes, operands=operands, results=results,
+  // CHECK:   super().__init__(self.build_generic(
+  // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def f32(self):
   // CHECK:   return self.operation.operands[1]
   let arguments = (ins I32, F32:$f32, I64);
 
   // CHECK: @property
   // CHECK: def i32(self):
   // CHECK:   return self.operation.results[0]
   //
   // CHECK: @property
   // CHECK: def i64(self):
   // CHECK:   return self.operation.results[2]
   let results = (outs I32:$i32, F32, I64:$i64);
 }
 
 // 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: def __init__(self, non_variadic, variadic, *, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   operands.append(non_variadic)
   // CHECK:   operands.extend(variadic)
-  // CHECK:   super().__init__(self._ods_build_default(
-  // CHECK:     attributes=attributes, operands=operands, results=results,
+  // CHECK:   super().__init__(self.build_generic(
+  // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def non_variadic(self):
   // CHECK:   return self.operation.operands[0]
   //
   // CHECK: @property
   // CHECK: def variadic(self):
   // CHECK:   _ods_variadic_group_length = len(self.operation.operands) - 2 + 1
   // CHECK:   return self.operation.operands[1:1 + _ods_variadic_group_length]
   let arguments = (ins AnyType:$non_variadic, Variadic<AnyType>:$variadic);
 }
 
 // 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, variadic, non_variadic, *, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   results.extend(variadic)
   // CHECK:   results.append(non_variadic)
-  // CHECK:   super().__init__(self._ods_build_default(
-  // CHECK:     attributes=attributes, operands=operands, results=results,
+  // CHECK:   super().__init__(self.build_generic(
+  // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @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: @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: def __init__(self, in_, *, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   operands.append(in_)
-  // CHECK:   super().__init__(self._ods_build_default(
-  // CHECK:     attributes=attributes, operands=operands, results=results,
+  // CHECK:   super().__init__(self.build_generic(
+  // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def in_(self):
   // CHECK:   return self.operation.operands[0]
   let arguments = (ins AnyType:$in);
 }
 
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, i64, f64, i32, f32, *, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   results.append(i64)
   // CHECK:   results.append(f64)
   // CHECK:   operands.append(i32)
   // CHECK:   operands.append(f32)
-  // CHECK:   super().__init__(self._ods_build_default(
-  // CHECK:     attributes=attributes, operands=operands, results=results,
+  // CHECK:   super().__init__(self.build_generic(
+  // CHECK:     attributes=attributes, results=results, operands=operands,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def i32(self):
   // CHECK:   return self.operation.operands[0]
   //
   // CHECK: @property
   // CHECK: def f32(self):

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

 
 /// Template for an optional element accessor:
 ///   {0} is the name of the accessor;
 ///   {1} is either 'operand' or 'result';
 ///   {2} is the total number of element groups;
 ///   {3} is the position of the current group in the group list.
 constexpr const char *opOneOptionalTemplate = R"Py(
   @property
-  def {0}(self);
-    return self.operation.{1}s[{3}] if len(self.operation.{1}s) > {2}
-                                    else None
+  def {0}(self):
+    return self.operation.{1}s[{3}] if len(self.operation.{1}s) > {2} else None
 )Py";
 
 /// Template for the variadic group accessor in the single variadic group case:
 ///   {0} is the name of the accessor;
 ///   {1} is either 'operand' or 'result';
 ///   {2} is the total number of element groups;
 ///   {3} is the position of the current group in the group list.
 constexpr const char *opOneVariadicTemplate = R"Py(
static bool isPythonKeyword(StringRef str) {
   return keywords.contains(str);
 }
 
 /// Checks whether `str` would shadow a generated variable or attribute
 /// part of the OpView API.
 static bool isODSReserved(StringRef str) {
   static llvm::StringSet<> reserved(
       {"attributes", "create", "context", "ip", "operands", "print", "get_asm",
-       "loc", "verify", "regions", "result", "results", "self", "operation",
+       "loc", "verify", "regions", "results", "self", "operation",
        "DIALECT_NAMESPACE", "OPERATION_NAME"});
   return str.startswith("_ods_") || str.endswith("_ods") ||
          reserved.contains(str);
 }
 
 /// Modifies the `name` in a way that it becomes suitable for Python bindings
 /// (does not change the `name` if it already is suitable) and returns the
 /// modified version.

 ///       `loc` and `ip`;
 ///   {1} is the code populating `operands`, `results` and `attributes` fields.
 constexpr const char *initTemplate = R"Py(
   def __init__(self, {0}):
     operands = []
     results = []
     attributes = {{}
     {1}
-    super().__init__(self._ods_build_default(
-      attributes=attributes, operands=operands, results=results,
+    super().__init__(self.build_generic(
+      attributes=attributes, results=results, operands=operands,
       loc=loc, ip=ip))
 )Py";
 
 /// Template for appending a single element to the operand/result list.
 ///   {0} is either 'operand' or 'result';
 ///   {1} is the field name.
 constexpr const char *singleElementAppendTemplate = "{0}s.append({1})";
 

 /// Additionally, `operandNames` is populated with names of operands in their
 /// order of appearance.
 static void
 populateBuilderArgs(const Operator &op,
                     llvm::SmallVectorImpl<std::string> &builderArgs,
                     llvm::SmallVectorImpl<std::string> &operandNames) {
   for (int i = 0, e = op.getNumResults(); i < e; ++i) {
     std::string name = op.getResultName(i).str();
-    if (name.empty())
+    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);
   }
   for (int i = 0, e = op.getNumArgs(); i < e; ++i) {
     std::string name = op.getArgName(i).str();
     if (name.empty())
       name = llvm::formatv("_gen_arg_{0}", i);
     name = sanitizeName(name);
populateBuilderLines(
       llvm::makeArrayRef(builderArgs).take_front(op.getNumResults()),
       builderLines, getNumResults, getResult);
   populateBuilderLines(op, "operand", operandArgNames, builderLines,
                        getNumOperands, getOperand);
   populateBuilderLinesAttr(
       op, llvm::makeArrayRef(builderArgs).drop_front(op.getNumResults()),
       builderLines);
 
+  builderArgs.push_back("*");
   builderArgs.push_back("loc=None");
   builderArgs.push_back("ip=None");
   os << llvm::formatv(initTemplate, llvm::join(builderArgs, ", "),
                       llvm::join(builderLines, "\n    "));
 }
 
 static void constructAttributeMapping(const llvm::RecordKeeper &records,
                                       AttributeClasses &attributeClasses) {