[mlir][python] Replace PythonAttr mappings with downcasting

[rkayaith]

Summary

Since op Attributes are automatically downcasted on access, these mappings
aren't necessary anymore. Instead we just always generate the getters/setters
for attributes even if there isn't a PythonAttr mapping.

depends on D154462

[ftynse]

Nice!

mlir/include/mlir/Bindings/Python/Attributes.td

 
 // A mapping between the attribute storage type and the corresponding Python
 // type. There is not necessarily a 1-1 match for non-builtin attributes.
 class PythonAttr<string c, string p> {
   string cppStorageType = c;
   string pythonType = p;
 }
 
-// Mappings between supported builtin attribtues and Python types.
-def : PythonAttr<"::mlir::Attribute", "_ods_ir.Attribute">;
-def : PythonAttr<"::mlir::BoolAttr", "_ods_ir.BoolAttr">;
-def : PythonAttr<"::mlir::IntegerAttr", "_ods_ir.IntegerAttr">;
-def : PythonAttr<"::mlir::FloatAttr", "_ods_ir.FloatAttr">;
-def : PythonAttr<"::mlir::StringAttr", "_ods_ir.StringAttr">;
-def : PythonAttr<"::mlir::DenseElementsAttr", "_ods_ir.DenseElementsAttr">;
-def : PythonAttr<"::mlir::DenseIntElementsAttr", "_ods_ir.DenseIntElementsAttr">;
-def : PythonAttr<"::mlir::DenseFPElementsAttr", "_ods_ir.DenseFPElementsAttr">;
-
 #endif

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

 // RUN: mlir-tblgen -gen-python-op-bindings -bind-dialect=test -I %S/../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Bindings/Python/Attributes.td"
 
 // CHECK: @_ods_cext.register_dialect
 // CHECK: class _Dialect(_ods_ir.Dialect):
   // CHECK: DIALECT_NAMESPACE = "test"
   // CHECK: pass
 def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "Test";
 }
+def TestAttr : AttrDef<Test_Dialect, "TestAttr">;
+def : PythonAttr<TestAttr.cppType, "<TestAttr hook>">;
+
 class TestOp<string mnemonic, list<Trait> 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,0,]
 def AttrSizedOperandsOp : TestOp<"attr_sized_operands",

 
 
 // 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, in_, *, optionalF32Attr=None, unitAttr=None, loc=None, ip=None):
+  // CHECK: def __init__(self, i32attr, in_, test_attr, *, optionalF32Attr=None, unitAttr=None, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   regions = None
   // CHECK:   attributes["i32attr"] = (i32attr if (
   // CHECK-NEXT:   issubclass(type(i32attr), _ods_ir.Attribute) or
   // CHECK-NEXT:   not _ods_ir.AttrBuilder.contains('I32Attr')
   // CHECK-NEXT:   _ods_ir.AttrBuilder.get('I32Attr')(i32attr, context=_ods_context)
   // 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:   _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))
 
   // CHECK: @builtins.property
   // CHECK: def i32attr(self):
-  // CHECK:   return _ods_ir.IntegerAttr(self.operation.attributes["i32attr"])
+  // CHECK:   return (self.operation.attributes["i32attr"])
 
   // CHECK: @builtins.property
   // CHECK: def optionalF32Attr(self):
   // CHECK:   if "optionalF32Attr" not in self.operation.attributes:
   // CHECK:     return None
-  // CHECK:   return _ods_ir.FloatAttr(self.operation.attributes["optionalF32Attr"])
+  // CHECK:   return (self.operation.attributes["optionalF32Attr"])
 
   // CHECK: @builtins.property
   // CHECK: def unitAttr(self):
   // CHECK:   return "unitAttr" in self.operation.attributes
 
   // CHECK: @builtins.property
   // CHECK: def in_(self):
-  // CHECK:   return _ods_ir.IntegerAttr(self.operation.attributes["in"])
+  // CHECK:   return (self.operation.attributes["in"])
+
+  // CHECK: @builtins.property
+  // CHECK: def test_attr(self):
+  // CHECK:   return <TestAttr hook>(self.operation.attributes["test_attr"])
   let arguments = (ins I32Attr:$i32attr, OptionalAttr<F32Attr>:$optionalF32Attr,
-                   UnitAttr:$unitAttr, I32Attr:$in);
+                   UnitAttr:$unitAttr, I32Attr:$in, TestAttr:$test_attr);
 }
 
 // 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"> {
def AttributedOpWithOperands : TestOp<"attributed_op_with_operands"> {
   // CHECK: @builtins.property
   // CHECK: def in_(self):
   // CHECK:   return "in" in self.operation.attributes
 
   // 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"])
+  // CHECK:   return (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):

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

if (namedAttr.attr.getStorageType().trim().equals("::mlir::UnitAttr")) {
                           namedAttr.name);
       os << llvm::formatv(unitAttributeSetterTemplate, sanitizedName,
                           namedAttr.name);
       os << llvm::formatv(attributeDeleterTemplate, sanitizedName,
                           namedAttr.name);
       continue;
     }
 
-    // Other kinds of attributes need a mapping to a Python type.
-    if (!attributeClasses.count(namedAttr.attr.getStorageType().trim()))
-      continue;
-
     StringRef pythonType =
         attributeClasses.lookup(namedAttr.attr.getStorageType());
     if (namedAttr.attr.isOptional()) {
       os << llvm::formatv(optionalAttributeGetterTemplate, sanitizedName,
                           pythonType, namedAttr.name);
       os << llvm::formatv(optionalAttributeSetterTemplate, sanitizedName,
                           namedAttr.name);
       os << llvm::formatv(attributeDeleterTemplate, sanitizedName,