Preliminary python API for constructing operations.

[stellaraccident]

Summary

• Primarily, this is just the scaffolding that allows a minimal operation to be created in the hierarchy.
• A follow-up needs to focus on more pythonic/complete mechanisms for traversing the operation hierarchy
• Threads through enough to test that the ownership model is sound and does not leak (verified with asan).

[mehdi_amini]

mlir/lib/Bindings/Python/IRModules.cpp

1015

We could reset the PyRegion reference to the new region held by the operation to avoid the dangling pointer I mention below.

It seems that to be really robust, we need some mechanism to keep a pointer back to the Py* objects almost everywhere, and we need to manage updates/invalidation as we will mutate the IR. It seems that any IR mutation outside Python method runs the risk of dangling pointers and later possible crashes when accessing these Python objects.

mlir/lib/Bindings/Python/IRModules.h

137

The extra context reference seems redundant with the MlirOperation: we should have an accessor to get the context from it.

(Same for PyModule)

mlir/test/Bindings/Python/ir_operation.py

103

I suspect that the region1 and region2 are dangling after the create_operation call and trying to use them would crash.

[stellaraccident]

Example changes to show how comments can be addressed.

[stellaraccident]

mlir/lib/Bindings/Python/IRModules.cpp

1015

I made a hacky change here and to the corresponding test showing that this does indeed fix the dangling pointer. This needs a clean up, but I figure we're going to be discussing this for a bit and I wanted to show how it can work before a more invasive fix.

Regarding the "really robust" part, I agree but have been having trouble finding a design that gets us there and doesn't overly sacrifice legibility or accounting tax. I feel like how we model these mutable parts of the IR are pretty core and now that we are here, probably worth a more involved discussion.

I think we can likely get this factored so that Python-only inspection and mutation does not have any design-imposed (unfixable) lifetime or memory safety issues.

I've been toying with some mechanism for carrying around a context-owned lock on every mutable object that defines the scope in which the object is still valid (attempts to do anything to an invalid object would raise an error). This could be as simple as an incrementing integer value for each lock, with the possibility of auto-acquiring a lock if just open-coding against the API (i.e. only doing python mutations). If wanting to do anything more scoped, you would need to enter a context lock with something like:

module = ctx.parse_module(...)
with ctx:
  op = module.operation.first_region.first_block.first_operation
  # Do some queries and mutations

# Outside of the lock scope, any python references to parts of the Operation hierarchy would error on use.

Global APIs that perform unrestricted mutations (i.e. PassManager, etc) would take a new lock, invalidating any existing one.

If we had the lock facility that we had to manage anyway, we might want to also rework our cascading keep_alives to somehow instead tie created objects to the lock scope, in lieu of the current mess we have of keep_alives on non-context temporaries.

Shall we switch to discourse? I can try to come up with some options and then we can decide. Right now, the way the API is laid out, it is not possible to provide stronger lifetime guarantees, which isn't great, and as you've noted in other reviews, the keep_alive situation is imprecise and wasteful.

mlir/test/Bindings/Python/ir_operation.py

103

I didn't believe you so I tried and you are correct. I'm missing something in my mental model of how ownership is transferred into the operation. I had thought that it was just about who owned the pointer, but it is also about the pointer itself. It's a vague question, but can you explain why this was obvious to you?

The transfer semantics appear to be different for region and block: for the latter, the pointer remains valid. Not sure how much of this is implementation details that should be coded defensively.

[ftynse]

mlir/lib/Bindings/Python/IRModules.cpp

953–954

Why do we have a vector of PyType but a vector of pointers to everything else?

956

I'd consider a py::dict, potentially as an overload if we see lots of overhead in creating Identifiers on the fly.

1015

I like the context approach. +1 for moving to discourse.

mlir/test/Bindings/Python/ir_operation.py

79

This starts to diverge between ctx.create_operation / ctx.get_unknown_location and mlir.ir.StringAttr.get(ctx,..., and mlir.ir.F32Type(ctx). I'd prefer one consistent way of creating things.

Independently, there's no need to expose create_operation on a context object because loc can provide the context.

103

In C++, when you create an operation with regions, you std::move those regions into the constructor so they are unusable after that.

Under the hood, regions held by an operation are allocated together with the operation itself, and then the _contents_ of the region is moved. I suppose we can update the MlirRegion object to point to those new regions, and then it should become safe for Python to use after calling the op.

[zhanghb97]

mlir/lib/Bindings/Python/IRModules.cpp

952

Should the PyLocation follow the rule in the D87091 - "making the location optional and internally creating an UnknownLocation if needed"?

[mehdi_amini]

mlir/test/Bindings/Python/ir_operation.py

103

It's a vague question, but can you explain why this was obvious to you?

I am just very familiar with this piece of infrastructure, and in particular I never really liked the way the OperationState is structured and exposed.

mlir/lib/Bindings/Python/IRModules.h

 //===- IRModules.h - IR Submodules of pybind module -----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_BINDINGS_PYTHON_IRMODULES_H
 #define MLIR_BINDINGS_PYTHON_IRMODULES_H
 
 #include <pybind11/pybind11.h>
 
 #include "mlir-c/IR.h"
 
 namespace mlir {
 namespace python {
 
 class PyMlirContext;
 class PyModule;

 public:
   PyLocation(MlirLocation loc) : loc(loc) {}
   MlirLocation loc;
 };
 
 /// Wrapper around MlirModule.
 class PyModule {
 public:
-  PyModule(MlirModule module) : module(module) {}
+  PyModule(MlirContext context, MlirModule module)
+      : context(context), module(module) {}
   PyModule(PyModule &) = delete;
   PyModule(PyModule &&other) {
+    context = other.context;
     module = other.module;
     other.module.ptr = nullptr;
   }
   ~PyModule() {
     if (module.ptr)
       mlirModuleDestroy(module);
   }
 
+  MlirContext context;
   MlirModule module;
 };
 
 /// Wrapper around an MlirRegion.
 /// Note that region can exist in a detached state (where this instance is
 /// responsible for clearing) or an attached state (where its owner is
 /// responsible).
 ///
 /// This python wrapper retains a redundant reference to its creating context
 /// in order to facilitate checking that parts of the operation hierarchy
 /// are only assembled from the same context.
 class PyRegion {
 public:
   PyRegion(MlirContext context, MlirRegion region, bool detached)
       : context(context), region(region), detached(detached) {}
+  PyRegion(const PyRegion &) = delete;
   PyRegion(PyRegion &&other)
       : context(other.context), region(other.region), detached(other.detached) {
     other.detached = false;
   }
   ~PyRegion() {
     if (detached)
       mlirRegionDestroy(region);
   }
 
   // Call prior to attaching the region to a parent.
   // This will transition to the attached state and will throw an exception
   // if already attached.
-  void attachToParent();
+  // If checkOnly is true, the check is performed but the detached state is not
+  // modified.
+  void attachToParent(bool checkOnly = false);
 
   MlirContext context;
   MlirRegion region;
 
 private:
   bool detached;
 };
 
 /// Wrapper around an MlirBlock.
 /// Note that blocks can exist in a detached state (where this instance is
 /// responsible for clearing) or an attached state (where its owner is
 /// responsible).
 ///
 /// This python wrapper retains a redundant reference to its creating context
 /// in order to facilitate checking that parts of the operation hierarchy
 /// are only assembled from the same context.
 class PyBlock {
 public:
   PyBlock(MlirContext context, MlirBlock block, bool detached)
       : context(context), block(block), detached(detached) {}
+  PyBlock(const PyBlock &) = delete;
   PyBlock(PyBlock &&other)
       : context(other.context), block(other.block), detached(other.detached) {
     other.detached = false;
   }
   ~PyBlock() {
     if (detached)
       mlirBlockDestroy(block);
   }
 
   // Call prior to attaching the block to a parent.
   // This will transition to the attached state and will throw an exception
   // if already attached.
-  void attachToParent();
+  // If checkOnly is true, the check is performed but the detached state is not
+  // modified.
+  void attachToParent(bool checkOnly = false);
 
   MlirContext context;
   MlirBlock block;
 
 private:
   bool detached;
 };
 
+/// Wrapper around an MlirOperation.
+/// Note that operations can exist in a detached state (where this instance is
+/// responsible for clearing) or an attached state (where its owner is
+/// responsible).
+///
+/// This python wrapper retains a redundant reference to its creating context
+/// in order to facilitate checking that parts of the operation hierarchy
+/// are only assembled from the same context.
+class PyOperation {
+public:
+  PyOperation(MlirContext context, MlirOperation operation, bool detached)
+      : context(context), operation(operation), detached(detached) {}
+  PyOperation(const PyOperation &) = delete;
+  PyOperation(PyOperation &&other)
+      : context(other.context), operation(other.operation),
+        detached(other.detached) {
+    other.detached = false;
+  }
+  ~PyOperation() {
+    if (detached)
+      mlirOperationDestroy(operation);
+  }
+
+  // Call prior to attaching the operation to a parent.
+  // This will transition to the attached state and will throw an exception
+  // if already attached.
+  // If checkOnly is true, the check is performed but the detached state is not
+  // modified.
+  void attachToParent(bool checkOnly = false);
+
+  MlirContext context;
+  MlirOperation operation;
+
+private:
+  bool detached;
+};
+
 /// Wrapper around the generic MlirAttribute.
 /// The lifetime of a type is bound by the PyContext that created it.
 class PyAttribute {
 public:
   PyAttribute(MlirAttribute attr) : attr(attr) {}
   bool operator==(const PyAttribute &other);
 
   MlirAttribute attr;

mlir/lib/Bindings/Python/IRModules.cpp

static const char kContextGetFileLocationDocstring[] =
     R"(Gets a Location representing a file, line and column)";
 
 static const char kContextCreateBlockDocstring[] =
     R"(Creates a detached block)";
 
 static const char kContextCreateRegionDocstring[] =
     R"(Creates a detached region)";
 
+static const char kContextCreateOperationDocstring[] =
+    R"(Creates a detached operation.
+
+Args:
+  name: An operation name (as "dialect.operation").
+  location: The location to associate with the operation.
+  results: Optional list of result types the operation returns.
+  regions: Optional regions to add to the operation.
+  successors: Optional references to successor blocks.
+  attributes: Optional list of named attributes (as from Attribute.get_named()).
+)";
+
 static const char kRegionAppendBlockDocstring[] =
     R"(Appends a block to a region.
 
 Raises:
   ValueError: If the block is already attached to another region.
 )";
 
 static const char kRegionInsertBlockDocstring[] =

 }
 
 } // namespace
 
 //------------------------------------------------------------------------------
 // PyBlock, PyRegion, and PyOperation.
 //------------------------------------------------------------------------------
 
-void PyRegion::attachToParent() {
+void PyRegion::attachToParent(bool checkOnly) {
   if (!detached) {
     throw SetPyError(PyExc_ValueError, "Region is already attached to an op");
   }
+  if (!checkOnly)
     detached = false;
 }
 
-void PyBlock::attachToParent() {
+void PyBlock::attachToParent(bool checkOnly) {
   if (!detached) {
     throw SetPyError(PyExc_ValueError, "Block is already attached to an op");
   }
+  if (!checkOnly)
+    detached = false;
+}
+
+void PyOperation::attachToParent(bool checkOnly) {
+  if (!detached) {
+    throw SetPyError(PyExc_ValueError,
+                     "Operation is already attached to a block");
+  }
+  if (!checkOnly)
     detached = false;
 }
 
 //------------------------------------------------------------------------------
 // PyAttribute.
 //------------------------------------------------------------------------------
 
 bool PyAttribute::operator==(const PyAttribute &other) {
   return mlirAttributeEqual(attr, other.attr);

 // Populates the pybind11 IR submodule.
 //------------------------------------------------------------------------------
 
 void mlir::python::populateIRSubmodule(py::module &m) {
   // Mapping of MlirContext
   py::class_<PyMlirContext>(m, "Context")
       .def(py::init<>())
       .def(
+          "create_module",
+          [](PyMlirContext &self, PyLocation location) {
+            return PyModule(self.context, mlirModuleCreateEmpty(location.loc));
+          },
+          py::keep_alive<0, 1>(), py::arg("location"))
+      .def(
           "parse_module",
           [](PyMlirContext &self, const std::string module) {
             auto moduleRef =
                 mlirModuleCreateParse(self.context, module.c_str());
             // TODO: Rework error reporting once diagnostic engine is exposed
             // in C API.
             if (mlirModuleIsNull(moduleRef)) {
               throw SetPyError(
                   PyExc_ValueError,
                   "Unable to parse module assembly (see diagnostics)");
             }
-            return PyModule(moduleRef);
+            return PyModule(self.context, moduleRef);
           },
           py::keep_alive<0, 1>(), kContextParseDocstring)
       .def(
           "parse_attr",
           [](PyMlirContext &self, std::string attrSpec) {
             MlirAttribute type =
                 mlirAttributeParseGet(self.context, attrSpec.c_str());
             // TODO: Rework error reporting once diagnostic engine is exposed
py::class_<PyMlirContext>(m, "Context")
                     PyExc_ValueError,
                     "All types used to construct a block must be from "
                     "the same context as the block");
               }
             }
             llvm::SmallVector<MlirType, 4> types(pyTypes.begin(),
                                                  pyTypes.end());
             return PyBlock(self.context,
-                           mlirBlockCreate(types.size(), &types[0]),
+                           mlirBlockCreate(types.size(), types.data()),
                            /*detached=*/true);
           },
-          py::keep_alive<0, 1>(), kContextCreateBlockDocstring);
+          py::keep_alive<0, 1>(), kContextCreateBlockDocstring)
+      .def(
+          "create_operation",
+          // TODO: Add operands once Value is mapped and usable.
+          [](PyMlirContext &self, std::string name, PyLocation location,
+             llvm::Optional<std::vector<PyType>> results,
+             llvm::Optional<std::vector<PyRegion *>> regions,
+             llvm::Optional<std::vector<PyBlock *>> successors,
+             llvm::Optional<std::vector<PyNamedAttribute *>> attributes) {
+            MlirOperationState state =
+                mlirOperationStateGet(name.c_str(), location.loc);
+            // Add results (value type).
+            // TODO: Verify that types originate from the same context.
+            if (results) {
+              llvm::SmallVector<MlirType, 4> mlirResults(results->begin(),
+                                                         results->end());
+              mlirOperationStateAddResults(&state, mlirResults.size(),
+                                           mlirResults.data());
+            }
+            // Add owned regions (does not yet transfer ownership).
+            if (regions) {
+              llvm::SmallVector<MlirRegion, 4> mlirRegions;
+              mlirRegions.reserve(regions->size());
+              for (auto *region : *regions) {
+                // TODO: Verify that regions originate from the same context.
+                // TODO: Verify whether the python API allows None to be passed.
+                assert(region && "region cannot be null");
+                region->attachToParent(/*checkOnly=*/true);
+                mlirRegions.push_back(region->region);
+              }
+              mlirOperationStateAddOwnedRegions(&state, mlirRegions.size(),
+                                                mlirRegions.data());
+            }
+            // Add non-owned successor references.
+            if (successors) {
+              llvm::SmallVector<MlirBlock, 4> mlirSuccessors;
+              mlirSuccessors.reserve(successors->size());
+              for (auto *successor : *successors) {
+                // TODO: Verify that successors originate from the same context.
+                // TODO: Verify whether the python API allows None to be passed.
+                assert(successor && "successor cannot be null");
+                mlirSuccessors.push_back(successor->block);
+              }
+              mlirOperationStateAddSuccessors(&state, mlirSuccessors.size(),
+                                              mlirSuccessors.data());
+            }
+            // Add attributes.
+            if (attributes) {
+              llvm::SmallVector<MlirNamedAttribute, 4> mlirAttributes;
+              mlirAttributes.reserve(attributes->size());
+              for (auto *attr : *attributes) {
+                // TODO: Verify that attributes originate from the same context.
+                // TODO: Verify whether the python API allows None to be passed.
+                assert(attr && "attribute cannot be null");
+                mlirAttributes.push_back(attr->namedAttr);
+              }
+              mlirOperationStateAddAttributes(&state, mlirAttributes.size(),
+                                              mlirAttributes.data());
+            }
+
+            // Construct the operation.
+            MlirOperation operation = mlirOperationCreate(&state);
+            // Transfer ownership of children. These transfers must succeed by
+            // way of not being failable or having been verified in advance.
+            if (regions) {
+              for (auto it : llvm::enumerate(*regions)) {
+                it.value()->attachToParent();
+                // Reset to the ownership-transferred region.
+                // TODO: Clean up this attachToParent() method to do exactly
+                // what is needed here.
+                it.value()->region =
+                    mlirOperationGetRegion(operation, it.index());
+              }
+            }
+            return PyOperation(self.context, operation, /*detached=*/true);
+          },
+          py::keep_alive<0, 1>(), py::arg("name"), py::arg("location"),
+          py::arg("results") = py::none(), py::arg("regions") = py::none(),
+          py::arg("successors") = py::none(),
+          py::arg("attributes") = py::none(), kContextCreateOperationDocstring);
 
   py::class_<PyLocation>(m, "Location").def("__repr__", [](PyLocation &self) {
     PyPrintAccumulator printAccum;
     mlirLocationPrint(self.loc, printAccum.getCallback(),
                       printAccum.getUserData());
     return printAccum.join();
   });
 
   // Mapping of Module
   py::class_<PyModule>(m, "Module")
+      .def_property_readonly(
+          "operation",
+          [](PyModule &self) {
+            return PyOperation(self.context,
+                               mlirModuleGetOperation(self.module),
+                               /*detached=*/false);
+          },
+          py::keep_alive<0, 1>(), "Accesses the module as an operation")
       .def(
           "dump",
           [](PyModule &self) {
             mlirOperationDump(mlirModuleGetOperation(self.module));
           },
           kDumpDocstring)
       .def(
           "__str__",
py::class_<PyBlock>(m, "Block")
             MlirBlock block = mlirBlockGetNextInRegion(self.block);
             if (mlirBlockIsNull(block)) {
               throw SetPyError(PyExc_IndexError,
                                "Attempt to read past last block");
             }
             return PyBlock(self.context, block, /*detached=*/false);
           },
           py::keep_alive<0, 1>(), kBlockNextInRegionDocstring)
+      // TODO: Remove prepend_operation in favor of a pseudo-list. It is just
+      // here to test the ownership model while bootstrapping the API.
+      .def("prepend_operation",
+           [](PyBlock &self, PyOperation &operation) {
+             if (!mlirContextEqual(self.context, operation.context)) {
+               throw SetPyError(
+                   PyExc_ValueError,
+                   "Operation must have been created from the same context as "
+                   "this block");
+             }
+             operation.attachToParent();
+             mlirBlockInsertOwnedOperation(self.block, /*pos=*/0,
+                                           operation.operation);
+           })
       .def(
           "__str__",
           [](PyBlock &self) {
             PyPrintAccumulator printAccum;
             mlirBlockPrint(self.block, printAccum.getCallback(),
                            printAccum.getUserData());
             return printAccum.join();
           },
           kTypeStrDunderDocstring);
 
+  // Mapping of Operation.
+  py::class_<PyOperation>(m, "Operation")
+      .def_property_readonly(
+          "first_region",
+          [](PyOperation &self) {
+            if (mlirOperationGetNumRegions(self.operation) == 0) {
+              throw SetPyError(PyExc_IndexError, "Operation has no regions");
+            }
+            return PyRegion(self.context,
+                            mlirOperationGetRegion(self.operation, 0),
+                            /*detached=*/false);
+          },
+          py::keep_alive<0, 1>(), "Gets the operation's first region")
+      .def(
+          "__str__",
+          [](PyOperation &self) {
+            PyPrintAccumulator printAccum;
+            mlirOperationPrint(self.operation, printAccum.getCallback(),
+                               printAccum.getUserData());
+            return printAccum.join();
+          },
+          kTypeStrDunderDocstring);
+
   // Mapping of Type.
   py::class_<PyAttribute>(m, "Attribute")
       .def(
           "get_named",
           [](PyAttribute &self, std::string name) {
             return PyNamedAttribute(self.attr, std::move(name));
           },
           py::keep_alive<0, 1>(), "Binds a name to the attribute")

mlir/lib/Bindings/Python/PybindUtils.h

 //===- PybindUtils.h - Utilities for interop with pybind11 ------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_BINDINGS_PYTHON_PYBINDUTILS_H
 #define MLIR_BINDINGS_PYTHON_PYBINDUTILS_H
 
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
 
+namespace pybind11 {
+namespace detail {
+template <typename T>
+struct type_caster<llvm::Optional<T>> : optional_caster<llvm::Optional<T>> {};
+} // namespace detail
+} // namespace pybind11
+
 namespace mlir {
 namespace python {
 
 // Sets a python error, ready to be thrown to return control back to the
 // python runtime.
 // Correct usage:
 //   throw SetPyError(PyExc_ValueError, "Foobar'd");
 pybind11::error_already_set SetPyError(PyObject *excClass,
                                        const llvm::Twine &message);
 
 } // namespace python
 } // namespace mlir
 
 #endif // MLIR_BINDINGS_PYTHON_PYBINDUTILS_H

mlir/test/Bindings/Python/ir_operation.py

 # RUN: %PYTHON %s | FileCheck %s
 
 import mlir
 
 def run(f):
   print("\nTEST:", f.__name__)
   f()
 
 
 # CHECK-LABEL: TEST: testDetachedRegionBlock
 def testDetachedRegionBlock():
   ctx = mlir.ir.Context()
   t = mlir.ir.F32Type(ctx)
   region = ctx.create_region()
+  # TODO: Add a test for a block with no types (was causing an abort)
   block = ctx.create_block([t, t])
   # CHECK: <<UNLINKED BLOCK>>
   print(block)
 
 run(testDetachedRegionBlock)
 
 
 # CHECK-LABEL: TEST: testBlockTypeContextMismatch
def testBlockAppend():
   try:
     block_next = block_next.next_in_region
   except IndexError:
     pass
   else:
     raise RuntimeError("Expected exception not raised")
 
 run(testBlockAppend)
+
+# CHECK-LABEL: TEST: testOperationCreate
+def testOperationCreate():
+  ctx = mlir.ir.Context()
+  loc = ctx.get_unknown_location()
+  # Empty op.
+  op = ctx.create_operation("unnamed.empty", loc)
+  # CHECK: empty op: "unnamed.empty"() : () -> ()
+  print("empty op:", op)
+  # Attribute containing op.
+  op = ctx.create_operation("unnamed.with_attr", loc, attributes=[
+    mlir.ir.StringAttr.get(ctx, "attrvalue").get_named("attr1"),
+    mlir.ir.StringAttr.get(ctx, "attrvalue2").get_named("attr2"),
+  ])
+  # CHECK: attr op: "unnamed.with_attr"() {attr1 = "attrvalue", attr2 = "attrvalue2"} : () -> ()
+  print("attr op:", op)
+  # Op with results.
+  op = ctx.create_operation("unnamed.with_results", loc, results=[
+    mlir.ir.F32Type(ctx),
+    mlir.ir.F64Type(ctx),
+  ])
+  # CHECK: %0:2 = "unnamed.with_results"() : () -> (f32, f64)
+  print("results op:", op)
+
+  # Op with regions.
+  # TODO: DO NOT SUBMIT. Refactor this test to be a more principled test of
+  # ownership transfer and validity.
+  region1 = ctx.create_region()
+  region2 = ctx.create_region()
+  op = ctx.create_operation("unnamed.with_regions", loc, regions=[
+    region1,
+    region2,
+  ])
+  # CHECK: region op: "unnamed.with_regions"() ( {
+  # CHECK: },  {
+  # CHECK: }) : () -> ()
+  print("region op:", op)
+  block1 = ctx.create_block([])
+  region1.append_block(block1)  # Should not crash
+  # CHECK: block1: ^bb0:  // no predecessors
+  print("block1:", block1)  # Should not crash
+  block1.prepend_operation(ctx.create_operation("unnamed.inner", loc))
+  # CHECK: region op with block: "unnamed.with_regions"() ( {
+  # CHECK:   "unnamed.inner"() : () -> ()
+  print("region op with block:", op)
+
+  # TODO: Test operands once it is possible to create them.
+  # TODO: Test successor blocks once it is possible to create them.
+
+run(testOperationCreate)
+
+# CHECK-LABEL: TEST: testOperationInModule
+def testOperationInModule():
+  ctx = mlir.ir.Context()
+  loc = ctx.get_unknown_location()
+  m = ctx.create_module(loc)
+  block = m.operation.first_region.first_block
+  op = ctx.create_operation("unnamed.empty", loc)
+  block.prepend_operation(op)
+  # CHECK: module {
+  # CHECK:   "unnamed.empty"() : () -> ()
+  # CHECK: }
+  print(m)
+
+run(testOperationInModule)