[mlir][tablegen] Generate default attr values in Python bindings

[springerm]

Summary

When specifying an op attribute with a default value (via DefaultValuedAttr), the default value is a string of C++ code. In the general case, the default value of such an attribute cannot be translated to Python when generating the bindings. However, we can hard-code default Python values for frequently-used C++ default values.

This change adds a Python default value for empty ArrayAttrs.

[springerm]

update

[ftynse]

Thanks!

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

552

Nit: {1} is not None is more pythonic

669

Nit: why is the llvm:: prefix necessary here?

[springerm]

update

[jpienaar]

As discussed in the other thread, the better approach is to move the default attributes from being lazily instantiated when queried, to being eagerly created in C++ build method, that way None here is sufficient Python side and all default valued attributes are supported out of box.

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

def AttributedOpWithOperands : TestOp<"attributed_op_with_operands"> {
   // CHECK: @builtins.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 DefaultValuedAttrsOp(_ods_ir.OpView):
+// CHECK-LABEL: OPERATION_NAME = "test.default_valued_attrs"
+def DefaultValuedAttrsOp : TestOp<"default_valued_attrs"> {
+  // CHECK: def __init__(self, *, arr=None, unsupported=None, loc=None, ip=None):
+  // CHECK:   operands = []
+  // CHECK:   results = []
+  // CHECK:   attributes = {}
+  // CHECK:   regions = None
+  // CHECK:   attributes["arr"] = arr if arr is not None else _ods_ir.ArrayAttr.get([])
+  // CHECK:   unsupported is not None, "attribute unsupported must be specified"
+  // CHECK:   _ods_successors = None
+  // CHECK:   super().__init__(self.build_generic(
+  // CHECK:     attributes=attributes, results=results, operands=operands,
+  // CHECK:     successors=_ods_successors, regions=regions, loc=loc, ip=ip))
+
+  let arguments = (ins DefaultValuedAttr<I64ArrayAttr, "{}">:$arr,
+                       DefaultValuedAttr<I64ArrayAttr, "dummy_func()">:$unsupported);
+  let results = (outs);
+}
+
 // CHECK-LABEL: OPERATION_NAME = "test.derive_result_types_op"
 def DeriveResultTypesOp : TestOp<"derive_result_types_op", [FirstAttrDerivedResultType]> {
   // CHECK: def __init__(self, type, *, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   _ods_result_type_source_attr = attributes["type"]
   // CHECK:   _ods_derived_result_type = (
   // CHECK:       _ods_ir.TypeAttr(_ods_result_type_source_attr).value

 def WithSuccessorsOp : TestOp<"with_successors"> {
   // CHECK-NOT:  _ods_successors = None
   // CHECK:      _ods_successors = []
   // CHECK-NEXT: _ods_successors.append(successor)
   // CHECK-NEXT: _ods_successors.extend(successors)
   let successors = (successor AnySuccessor:$successor,
                               VariadicSuccessor<AnySuccessor>:$successors);
 }
-

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

 //===- OpPythonBindingGen.cpp - Generator of Python API for MLIR Ops ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // OpPythonBindingGen uses ODS specification of MLIR ops to generate Python
 // binding classes wrapping a generic operation API.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Support/LogicalResult.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/Operator.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 

 constexpr const char *initAttributeTemplate = R"Py(attributes["{0}"] = {1})Py";
 
 /// Template for setting an optional attribute in the operation builder.
 ///   {0} is the attribute name;
 ///   {1} is the builder argument name.
 constexpr const char *initOptionalAttributeTemplate =
     R"Py(if {1} is not None: attributes["{0}"] = {1})Py";
 
+/// Template for setting an attribute with a default value in the operation
+/// builder.
+///   {0} is the attribute name;
+///   {1} is the builder argument name;
+///   {2} is the default value.
+constexpr const char *initDefaultValuedAttributeTemplate =
+    R"Py(attributes["{0}"] = {1} if {1} is not None else {2})Py";
+
+/// Template for asserting that an attribute value was provided when calling a
+/// builder.
+///   {0} is the attribute name;
+///   {1} is the builder argument name.
+constexpr const char *assertAttributeValueSpecified =
+    R"Py(assert {1} is not None, "attribute {0} must be specified")Py";
+
 constexpr const char *initUnitAttributeTemplate =
     R"Py(if bool({1}): attributes["{0}"] = _ods_ir.UnitAttr.get(
       _ods_get_default_loc_context(loc)))Py";
 
 /// Template to initialize the successors list in the builder if there are any
 /// successors.
 ///   {0} is the value to initialize the successors list to.
 constexpr const char *initSuccessorsTemplate = R"Py(_ods_successors = {0})Py";
for (int i = 0, e = op.getNumSuccessors(); i < e; ++i) {
     if (name.empty())
       name = llvm::formatv("_gen_successor_{0}", i);
     name = sanitizeName(name);
     builderArgs.push_back(name);
     successorArgNames.push_back(name);
   }
 }
 
+/// Generates Python code for the default value of the given attribute.
+static FailureOr<std::string> getAttributeDefaultValue(Attribute attr) {
+  assert(attr.hasDefaultValue() && "expected attribute with default value");
+  StringRef storageType = attr.getStorageType().trim();
+  StringRef defaultValCpp = attr.getDefaultValue().trim();
+
+  // A list of commonly used attribute types and default values for which
+  // we can generate Python code. Extend as needed.
+  if (storageType.equals("::mlir::ArrayAttr") && defaultValCpp.equals("{}"))
+    return std::string("_ods_ir.ArrayAttr.get([])");
+
+  // No match: Cannot generate Python code.
+  return failure();
+}
+
 /// Populates `builderLines` with additional lines that are required in the
 /// builder to set up operation attributes. `argNames` is expected to contain
 /// the names of builder arguments that correspond to op arguments, i.e. to the
 /// operands and attributes in the same order as they appear in the `arguments`
 /// field.
 static void
 populateBuilderLinesAttr(const Operator &op,
                          llvm::ArrayRef<std::string> argNames,
                          llvm::SmallVectorImpl<std::string> &builderLines) {
   for (int i = 0, e = op.getNumArgs(); i < e; ++i) {
     Argument arg = op.getArg(i);
     auto *attribute = arg.dyn_cast<NamedAttribute *>();
     if (!attribute)
       continue;
 
     // Unit attributes are handled specially.
     if (attribute->attr.getStorageType().trim().equals("::mlir::UnitAttr")) {
       builderLines.push_back(llvm::formatv(initUnitAttributeTemplate,
                                            attribute->name, argNames[i]));
       continue;
     }
 
+    // Attributes with default value are handled specially.
+    if (attribute->attr.hasDefaultValue()) {
+      // In case we cannot generate Python code for the default value, the
+      // attribute must be specified by the user.
+      FailureOr<std::string> defaultValPy =
+          getAttributeDefaultValue(attribute->attr);
+      if (succeeded(defaultValPy)) {
+        builderLines.push_back(llvm::formatv(initDefaultValuedAttributeTemplate,
+                                             attribute->name, argNames[i],
+                                             *defaultValPy));
+      } else {
+        builderLines.push_back(llvm::formatv(assertAttributeValueSpecified,
+                                             attribute->name, argNames[i]));
+        builderLines.push_back(
+            llvm::formatv(initAttributeTemplate, attribute->name, argNames[i]));
+      }
+      continue;
+    }
+
     builderLines.push_back(llvm::formatv(attribute->attr.isOptional()
                                              ? initOptionalAttributeTemplate
                                              : initAttributeTemplate,
                                          attribute->name, argNames[i]));
   }
 }
 
 /// Populates `builderLines` with additional lines that are required in the