Add Python bindings for the OpaqueType

[dime10]

Summary

Implement the C-API and Python bindings for the builtin opaque type, which was previously missing.

[ftynse]

Thanks! This looks good, I only have a couple of nits and a small request to add a test for the C API somewhere here https://github.com/llvm/llvm-project/blob/main/mlir/test/CAPI/ir.c#L625.

mlir/include/mlir-c/BuiltinTypes.h

340–341

Any reason why the data is not accepted as MlirStringRef? It is returned as such, so I'd go for consistency here.

mlir/lib/Bindings/Python/IRTypes.cpp

636

Nit: add trailing dots in the documentation here and below.

[dime10]

mlir/include/mlir-c/BuiltinTypes.h

340–341

Hmm good question, I wanted to be consistent with the OpaqueAttribute , but I can change it.

[ftynse]

mlir/include/mlir-c/BuiltinTypes.h

340–341

That seems to have been overlooked when we introduced MlirStringRef, it is also worth changing :)

[dime10]

Implement suggestions from code review

• punctuation in docstrings
• use StringRef instead of char*
• add C-API test

[dime10]

Thanks a lot for your review @ftynse :)

[dime10]

Include both commits in the patch

[dime10]

Fix C-API test failure

[dime10]

@ftynse Are you able to merge this in for me? :)

mlir/include/mlir-c/BuiltinTypes.h

 /// Returns the pos-th input type.
 MLIR_CAPI_EXPORTED MlirType mlirFunctionTypeGetInput(MlirType type,
                                                      intptr_t pos);
 
 /// Returns the pos-th result type.
 MLIR_CAPI_EXPORTED MlirType mlirFunctionTypeGetResult(MlirType type,
                                                       intptr_t pos);
 
+//===----------------------------------------------------------------------===//
+// Opaque type.
+//===----------------------------------------------------------------------===//
+
+/// Checks whether the given type is an opaque type.
+MLIR_CAPI_EXPORTED bool mlirTypeIsAOpaque(MlirType type);
+
+/// Creates an opaque type in the given context associated with the dialect
+/// identified by its namespace. The type contains opaque byte data of the
+/// specified length (data need not be null-terminated).
+MLIR_CAPI_EXPORTED MlirType mlirOpaqueTypeGet(MlirContext ctx,
+                                              MlirStringRef dialectNamespace,
+                                              MlirStringRef typeData);
+
+/// Returns the namespace of the dialect with which the given opaque type
+/// is associated. The namespace string is owned by the context.
+MLIR_CAPI_EXPORTED MlirStringRef
+mlirOpaqueTypeGetDialectNamespace(MlirType type);
+
+/// Returns the raw data as a string reference. The data remains live as long as
+/// the context in which the type lives.
+MLIR_CAPI_EXPORTED MlirStringRef mlirOpaqueTypeGetData(MlirType type);
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_BUILTINTYPES_H

mlir/lib/Bindings/Python/IRTypes.cpp

c.def_property_readonly(
                 PyType(contextRef, mlirFunctionTypeGetResult(self, i)));
           }
           return types;
         },
         "Returns the list of result types in the FunctionType.");
   }
 };
 
+static MlirStringRef toMlirStringRef(const std::string &s) {
+  return mlirStringRefCreate(s.data(), s.size());
+}
+
+/// Opaque Type subclass - OpaqueType.
+class PyOpaqueType : public PyConcreteType<PyOpaqueType> {
+public:
+  static constexpr IsAFunctionTy isaFunction = mlirTypeIsAOpaque;
+  static constexpr const char *pyClassName = "OpaqueType";
+  using PyConcreteType::PyConcreteType;
+
+  static void bindDerived(ClassTy &c) {
+    c.def_static(
+        "get",
+        [](std::string dialectNamespace, std::string typeData,
+           DefaultingPyMlirContext context) {
+          MlirType type = mlirOpaqueTypeGet(context->get(),
+                                            toMlirStringRef(dialectNamespace),
+                                            toMlirStringRef(typeData));
+          return PyOpaqueType(context->getRef(), type);
+        },
+        py::arg("dialect_namespace"), py::arg("buffer"),
+        py::arg("context") = py::none(),
+        "Create an unregistered (opaque) dialect type.");
+    c.def_property_readonly(
+        "dialect_namespace",
+        [](PyOpaqueType &self) {
+          MlirStringRef stringRef = mlirOpaqueTypeGetDialectNamespace(self);
+          return py::str(stringRef.data, stringRef.length);
+        },
+        "Returns the dialect namespace for the Opaque type as a string.");
+    c.def_property_readonly(
+        "data",
+        [](PyOpaqueType &self) {
+          MlirStringRef stringRef = mlirOpaqueTypeGetData(self);
+          return py::str(stringRef.data, stringRef.length);
+        },
+        "Returns the data for the Opaque type as a string.");
+  }
+};
+
 } // namespace
 
 void mlir::python::populateIRTypes(py::module &m) {
   PyIntegerType::bind(m);
   PyIndexType::bind(m);
   PyBF16Type::bind(m);
   PyF16Type::bind(m);
   PyF32Type::bind(m);
   PyF64Type::bind(m);
   PyNoneType::bind(m);
   PyComplexType::bind(m);
   PyShapedType::bind(m);
   PyVectorType::bind(m);
   PyRankedTensorType::bind(m);
   PyUnrankedTensorType::bind(m);
   PyMemRefType::bind(m);
   PyUnrankedMemRefType::bind(m);
   PyTupleType::bind(m);
   PyFunctionType::bind(m);
+  PyOpaqueType::bind(m);
 }

mlir/lib/CAPI/IR/BuiltinTypes.cpp

 //===- BuiltinTypes.cpp - C Interface to MLIR Builtin Types ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir-c/BuiltinTypes.h"
 #include "mlir-c/AffineMap.h"
 #include "mlir-c/IR.h"
 #include "mlir/CAPI/AffineMap.h"
 #include "mlir/CAPI/IR.h"
+#include "mlir/CAPI/Support.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Types.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Integer types.
return wrap(
       unwrap(type).cast<FunctionType>().getInput(static_cast<unsigned>(pos)));
 }
 
 MlirType mlirFunctionTypeGetResult(MlirType type, intptr_t pos) {
   assert(pos >= 0 && "pos in array must be positive");
   return wrap(
       unwrap(type).cast<FunctionType>().getResult(static_cast<unsigned>(pos)));
 }
+
+//===----------------------------------------------------------------------===//
+// Opaque type.
+//===----------------------------------------------------------------------===//
+
+bool mlirTypeIsAOpaque(MlirType type) { return unwrap(type).isa<OpaqueType>(); }
+
+MlirType mlirOpaqueTypeGet(MlirContext ctx, MlirStringRef dialectNamespace,
+                           MlirStringRef typeData) {
+  return wrap(
+      OpaqueType::get(StringAttr::get(unwrap(ctx), unwrap(dialectNamespace)),
+                      unwrap(typeData)));
+}
+
+MlirStringRef mlirOpaqueTypeGetDialectNamespace(MlirType type) {
+  return wrap(unwrap(type).cast<OpaqueType>().getDialectNamespace().strref());
+}
+
+MlirStringRef mlirOpaqueTypeGetData(MlirType type) {
+  return wrap(unwrap(type).cast<OpaqueType>().getTypeData());
+}

mlir/python/mlir/_mlir_libs/_mlir/ir.pyi

__all__ = [
     "IntegerSetConstraint",
     "IntegerSetConstraintList",
     "IntegerType",
     "Location",
     "MemRefType",
     "Module",
     "NamedAttribute",
     "NoneType",
+    "OpaqueType",
     "OpAttributeMap",
     "OpOperandList",
     "OpResult",
     "OpResultList",
     "OpView",
     "Operation",
     "OperationIterator",
     "OperationList",

 # TODO: Auto-generated. Audit and fix.
 class NoneType(Type):
     def __init__(self, cast_from_type: Type) -> None: ...
     @staticmethod
     def get(*args, **kwargs) -> NoneType: ...
     @staticmethod
     def isinstance(arg: Any) -> bool: ...
 
+class OpaqueType(Type):
+    def __init__(self, cast_from_type: Type) -> None: ...
+    @staticmethod
+    def get(*args, **kwargs) -> OpaqueType: ...
+    @staticmethod
+    def isinstance(arg: Any) -> bool: ...
+    @property
+    def dialect_namespace(self) -> str: ...
+    @property
+    def data(self) -> str: ...
+
 class OpAttributeMap:
     def __contains__(self, arg0: str) -> bool: ...
     def __delitem__(self, arg0: str) -> None: ...
     @overload
     def __getitem__(self, arg0: str) -> Attribute: ...
     @overload
     def __getitem__(self, arg0: int) -> NamedAttribute: ...
     def __len__(self) -> int: ...

mlir/test/CAPI/ir.c

static int printBuiltinTypes(MlirContext ctx) {
   if (!mlirTypeEqual(funcResults[0], mlirFunctionTypeGetResult(funcType, 0)) ||
       !mlirTypeEqual(funcResults[1], mlirFunctionTypeGetResult(funcType, 1)) ||
       !mlirTypeEqual(funcResults[2], mlirFunctionTypeGetResult(funcType, 2)))
     return 24;
   mlirTypeDump(funcType);
   fprintf(stderr, "\n");
   // CHECK: (index, i1) -> (i16, i32, i64)
 
+  // Opaque type.
+  MlirStringRef namespace = mlirStringRefCreate("dialect", 7);
+  MlirStringRef data = mlirStringRefCreate("type", 4);
+  mlirContextSetAllowUnregisteredDialects(ctx, true);
+  MlirType opaque = mlirOpaqueTypeGet(ctx, namespace, data);
+  mlirContextSetAllowUnregisteredDialects(ctx, false);
+  if (!mlirTypeIsAOpaque(opaque) ||
+      !mlirStringRefEqual(mlirOpaqueTypeGetDialectNamespace(opaque),
+                          namespace) ||
+      !mlirStringRefEqual(mlirOpaqueTypeGetData(opaque), data))
+    return 25;
+  mlirTypeDump(opaque);
+  fprintf(stderr, "\n");
+  // CHECK: !dialect.type
+
   return 0;
 }
 
 void callbackSetFixedLengthString(const char *data, intptr_t len,
                                   void *userData) {
   strncpy(userData, data, len);
 }
 

mlir/test/python/ir/builtin_types.py

with Context() as ctx:
     input_types = [IntegerType.get_signless(32),
                   IntegerType.get_signless(16)]
     result_types = [IndexType.get()]
     func = FunctionType.get(input_types, result_types)
     # CHECK: INPUTS: [Type(i32), Type(i16)]
     print("INPUTS:", func.inputs)
     # CHECK: RESULTS: [Type(index)]
     print("RESULTS:", func.results)
+
+
+# CHECK-LABEL: TEST: testOpaqueType
+@run
+def testOpaqueType():
+  with Context() as ctx:
+    ctx.allow_unregistered_dialects = True
+    opaque = OpaqueType.get("dialect", "type")
+    # CHECK: opaque type: !dialect.type
+    print("opaque type:", opaque)
+    # CHECK: dialect namespace: dialect
+    print("dialect namespace:", opaque.dialect_namespace)
+    # CHECK: data: type
+    print("data:", opaque.data)