[mlir] Enable converting properties during C create

[jpienaar]

Summary

This enables querying properties passed as attributes during
construction time. In particular needed for type inference where the
Operation has not been created at this point. This allows Python
construction of operations whose type inference depends on properties.

Depends on D156041

[mehdi_amini]

mlir/include/mlir/IR/OperationSupport.h

986

If you can, push this as a separate commit, seems unrelated to me and it's the only change in this file.

mlir/lib/Bindings/Python/IRCore.cpp

2872

Seems weird to me?

mlir/lib/Bindings/Python/IRModule.h

659

Squash in parent?

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

933

Squash in parent

[jpienaar]

Move changes to parent

[mehdi_amini]

mlir/lib/CAPI/IR/IR.cpp

369

Could add !attributes.empty() as well here

[jpienaar]

Add check & clang-format

mlir/include/mlir/IR/OperationSupport.h

public:
   template <typename T>
   T &getOrAddProperties() {
     if (!properties) {
       T *p = new T{};
       properties = p;
       propertiesDeleter = [](OpaqueProperties prop) {
         delete prop.as<const T *>();
       };
-      propertiesSetter = [](OpaqueProperties new_prop,
+      propertiesSetter = [](OpaqueProperties newProp,
                             const OpaqueProperties prop) {
-        *new_prop.as<T *>() = *prop.as<const T *>();
+        *newProp.as<T *>() = *prop.as<const T *>();
       };
       propertiesId = TypeID::get<T>();
     }
     assert(propertiesId == TypeID::get<T>() && "Inconsistent properties");
     return *properties.as<T *>();
   }
+
   OpaqueProperties getRawProperties() { return properties; }
 
   // Set the properties defined on this OpState on the given operation,
   // optionally emit diagnostics on error through the provided diagnostic.
   LogicalResult setProperties(Operation *op,
                               InFlightDiagnostic *diagnostic) const;
 
   void addOperands(ValueRange newOperands);
 

mlir/lib/Bindings/Python/IRCore.cpp

void mlir::python::populateIRCore(py::module &m) {
 
   py::class_<PyOperation, PyOperationBase>(m, "Operation", py::module_local())
       .def_static("create", &PyOperation::create, py::arg("name"),
                   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(),
-                  py::arg("infer_type") = false, kOperationCreateDocstring)
+                  py::arg("infer_type") = false,
+                  kOperationCreateDocstring)
       .def_static(
           "parse",
           [](const std::string &sourceStr, const std::string &sourceName,
              DefaultingPyMlirContext context) {
             return PyOperation::parse(context->getRef(), sourceStr, sourceName)
                 ->createOpView();
           },
           py::arg("source"), py::kw_only(), py::arg("source_name") = "",

mlir/lib/Bindings/Python/IRModule.h

public:
 
   /// Creates an operation. See corresponding python docstring.
   static pybind11::object
   create(const std::string &name, std::optional<std::vector<PyType *>> results,
          std::optional<std::vector<PyValue *>> operands,
          std::optional<pybind11::dict> attributes,
          std::optional<std::vector<PyBlock *>> successors, int regions,
          DefaultingPyLocation location, const pybind11::object &ip,
-         bool inferType = false);
+         bool inferType);
 
   /// Creates an OpView suitable for this operation.
   pybind11::object createOpView();
 
   /// Erases the underlying MlirOperation, removes its pointer from the
   /// parent context's live operations map, and sets the valid bit false.
   void erase();
 

mlir/lib/CAPI/IR/IR.cpp

 #include "mlir-c/Support.h"
 
 #include "mlir/AsmParser/AsmParser.h"
 #include "mlir/Bytecode/BytecodeWriter.h"
 #include "mlir/CAPI/IR.h"
 #include "mlir/CAPI/Support.h"
 #include "mlir/CAPI/Utils.h"
 #include "mlir/IR/Attributes.h"
+#include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/Operation.h"
+#include "mlir/IR/OperationSupport.h"
 #include "mlir/IR/Types.h"
 #include "mlir/IR/Value.h"
 #include "mlir/IR/Verifier.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "mlir/Parser/Parser.h"
 
 #include <cstddef>
+#include <memory>
 #include <optional>
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Context API.
 //===----------------------------------------------------------------------===//
 

 //===----------------------------------------------------------------------===//
 
 static LogicalResult inferOperationTypes(OperationState &state) {
   MLIRContext *context = state.getContext();
   std::optional<RegisteredOperationName> info = state.name.getRegisteredInfo();
   if (!info) {
     emitError(state.location)
         << "type inference was requested for the operation " << state.name
-        << ", but the operation was not registered. Ensure that the dialect "
+        << ", but the operation was not registered; ensure that the dialect "
            "containing the operation is linked into MLIR and registered with "
            "the context";
     return failure();
   }
 
-  // Fallback to inference via an op interface.
   auto *inferInterface = info->getInterface<InferTypeOpInterface>();
   if (!inferInterface) {
     emitError(state.location)
         << "type inference was requested for the operation " << state.name
-        << ", but the operation does not support type inference. Result "
-           "types must be specified explicitly.";
+        << ", but the operation does not support type inference; result "
+           "types must be specified explicitly";
+    return failure();
+  }
+
+  DictionaryAttr attributes = state.attributes.getDictionary(context);
+  OpaqueProperties properties = state.getRawProperties();
+
+  if (!properties && info->getOpPropertyByteSize() > 0) {
+    auto prop = std::make_unique<char[]>(info->getOpPropertyByteSize());
+    properties = OpaqueProperties(prop.get());
+    if (failed(info->setOpPropertiesFromAttribute(state.name,
+                                       properties,
+                                       attributes, nullptr))) {
+      return failure();
+    }
+
+    if (succeeded(inferInterface->inferReturnTypes(
+            context, state.location, state.operands, attributes, properties,
+            state.regions, state.types))) {
+      return success();
+    }
+    // Diagnostic emitted by interface.
     return failure();
   }
 
   if (succeeded(inferInterface->inferReturnTypes(
-          context, state.location, state.operands,
-          state.attributes.getDictionary(context), state.getRawProperties(),
+          context, state.location, state.operands, attributes, properties,
           state.regions, state.types)))
     return success();
 
   // Diagnostic emitted by interface.
   return failure();
 }
 
 MlirOperation mlirOperationCreate(MlirOperationState *state) {
MlirOperation mlirOperationCreate(MlirOperationState *state) {
   // Infer result types.
   if (state->enableResultTypeInference) {
     assert(cppState.types.empty() &&
            "result type inference enabled and result types provided");
     if (failed(inferOperationTypes(cppState)))
       return {nullptr};
   }
 
-  MlirOperation result = wrap(Operation::create(cppState));
-  return result;
+  return wrap(Operation::create(cppState));
 }
 
 MlirOperation mlirOperationCreateParse(MlirContext context,
                                        MlirStringRef sourceStr,
                                        MlirStringRef sourceName) {
 
   return wrap(
       parseSourceString(unwrap(sourceStr), unwrap(context), unwrap(sourceName))

mlir/lib/Dialect/Shape/IR/Shape.cpp

void ConstShapeOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
   patterns.add<TensorCastConstShape>(context);
 }
 
 LogicalResult mlir::shape::ConstShapeOp::inferReturnTypes(
     MLIRContext *context, std::optional<Location> location,
     ConstShapeOp::Adaptor adaptor, SmallVectorImpl<Type> &inferredReturnTypes) {
   Builder b(context);
   const Properties prop = adaptor.getProperties();
-  DenseIntElementsAttr shape;
-  // TODO: this is only exercised by the Python bindings codepath which does not
-  // support properties
-  shape = prop.shape ? prop.shape : 
-            adaptor.getAttributes().getAs<DenseIntElementsAttr>("shape");
-  if (!shape)
-    return emitOptionalError(location, "missing shape attribute");
   inferredReturnTypes.assign({RankedTensorType::get(
-      {static_cast<int64_t>(shape.size())}, b.getIndexType())});
+      {static_cast<int64_t>(prop.shape.size())}, b.getIndexType())});
   return success();
 }
 
 bool mlir::shape::ConstShapeOp::isCompatibleReturnTypes(TypeRange l,
                                                         TypeRange r) {
   if (l.size() != 1 || r.size() != 1)
     return false;
 

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

 ///       `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,{2} operands=operands,
-      successors=_ods_successors, regions=regions, loc=loc, ip=ip))
+    super().__init__(self.build_generic({2}))
 )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})";
 
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");
+
+  SmallVector<std::string> initArgs;
+  initArgs.push_back("attributes=attributes");
+  if (!hasInferTypeInterface(op))
+      initArgs.push_back("results=results");
+  initArgs.push_back("operands=operands");
+  initArgs.push_back("successors=_ods_successors");
+  initArgs.push_back("regions=regions");
+  initArgs.push_back("loc=loc");
+  initArgs.push_back("ip=ip");
+
   os << llvm::formatv(initTemplate, llvm::join(functionArgs, ", "),
                       llvm::join(builderLines, "\n    "),
-                      hasInferTypeInterface(op) ? "" : " results=results,");
+                      llvm::join(initArgs, ", "));
 }
 
 static void emitSegmentSpec(
     const Operator &op, const char *kind,
     llvm::function_ref<int(const Operator &)> getNumElements,
     llvm::function_ref<const NamedTypeConstraint &(const Operator &, int)>
         getElement,
     raw_ostream &os) {