[mlir][python] Remove PythonAttr mapping functionality

[rkayaith]

Summary

This functionality has been replaced by TypeCasters (see D151840)

depends on D154468

[ftynse]

mlir/docs/Bindings/Python.md

1128–1130

The extra files under python/mlir/dialects where added specifically to include Attributes.td. Can we remove them entirely now that we don't need the other include?

[aartbik]

lg for the sparse part, once other comment is addressed

[rkayaith]

mlir/docs/Bindings/Python.md

1128–1130

I had tried that initially, but the declare_mlir_dialect_python_bindings cmake function uses the .td file path to determine where to place the generated python file:

• mlir/python/CMakeLists.txt
• AddMLIRPython.cmake

I could make relative_td_directory there an argument to declare_mlir_dialect_python_bindings though, let me try that.

1132–1138

Any particular reason the table-generated python file shouldn't be called <dialect-namespace>.py? While I'm at it I could try to get rid of the ones that are just from ._dialect_ops_gen import *.

[ftynse]

LGTM. Cmake changes and file deletion can come in a separate patch. Please ping be on discord or some other chat channel if you need me to take another look at this.

mlir/docs/Bindings/Python.md

1128–1130

I see. No need to block this patch on cmake changes, those can come later as long as this patch has a TODO. Thanks!

1132–1138

Many dialect packages have more initialization than just importing the generated bindings. Furthermore, the mixin mechanism relies on the files being named _dialect_ops_gen and _dialect_ops_ext, respectively. I'd rather keep this as is and not introduce extra complexity in the build system (choosing whether to generate an _ops_gen file or directly a dialect files) to spare a dozen lines of boilerplate.

mlir/cmake/modules/AddMLIRPython.cmake

 #   ROOT_DIR: Same as for declare_mlir_python_sources().
 #   ADD_TO_PARENT: Same as for declare_mlir_python_sources(). Unique names
 #     for the subordinate source groups are derived from this.
 #   TD_FILE: Tablegen file to generate source for (relative to ROOT_DIR).
 #   DIALECT_NAME: Python name of the dialect.
 #   SOURCES: Same as declare_mlir_python_sources().
 #   SOURCES_GLOB: Same as declare_mlir_python_sources().
 #   DEPENDS: Additional dependency targets.
+#
+# TODO: Right now `TD_FILE` can't be the actual dialect tablegen file, since we
+#       use its path to determine where to place the generated python file. If
+#       we made the output path an additional argument here we could remove the
+#       need for the separate "wrapper" .td files
 function(declare_mlir_dialect_python_bindings)
   cmake_parse_arguments(ARG
     ""
     "ROOT_DIR;ADD_TO_PARENT;TD_FILE;DIALECT_NAME"
     "SOURCES;SOURCES_GLOB;DEPENDS"
     ${ARGN})
   # Sources.
   set(_dialect_target "${ARG_ADD_TO_PARENT}.${ARG_DIALECT_NAME}")

mlir/docs/Bindings/Python.md

 invoking `mlir-tblgen` on a python-bindings specific tablegen wrapper that
 includes the boilerplate and actual dialect specific `td` file. An example, for
 the `Func` (which is assigned the namespace `func` as a special case):
 
 ```tablegen
 #ifndef PYTHON_BINDINGS_FUNC_OPS
 #define PYTHON_BINDINGS_FUNC_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Func/IR/FuncOps.td"
 
 #endif // PYTHON_BINDINGS_FUNC_OPS
 ```
 
 In the main repository, building the wrapper is done via the CMake function
 `declare_mlir_dialect_python_bindings`, which invokes:
 

 
 ### Operations
 
 Dialect operations are provided in Python by wrapping the generic
 `mlir.ir.Operation` class with operation-specific builder functions and
 properties. Therefore, there is no need to implement a separate C API for them.
 For operations defined in ODS, `mlir-tblgen -gen-python-op-bindings
 -bind-dialect=<dialect-namespace>` generates the Python API from the declarative
-description. If the build API uses specific attribute types, such as
-`::mlir::IntegerAttr` or `::mlir::DenseIntElementsAttr`, for its arguments, the
-mapping to the corresponding Python types should be provided in ODS definition.
-For built-in attribute types, this mapping is available in
-[`include/mlir/Bindings/Python/Attributes.td`](https://github.com/llvm/llvm-project/blob/main/mlir/include/mlir/Bindings/Python/Attributes.td);
-it is sufficient to create a new `.td` file that includes this file and the
-original ODS definition and use it as source for the `mlir-tblgen` call. Such
-`.td` files reside in
+description.
+It is sufficient to create a new `.td` file that includes the original ODS
+definition and use it as source for the `mlir-tblgen` call.
+Such `.td` files reside in
 [`python/mlir/dialects/`](https://github.com/llvm/llvm-project/tree/main/mlir/python/mlir/dialects).
 The results of `mlir-tblgen` are expected to produce a file named
 `_<dialect-namespace>_ops_gen.py` by convention. The generated operation classes
 can be extended as described above. MLIR provides [CMake
 functions](https://github.com/llvm/llvm-project/blob/main/mlir/cmake/modules/AddMLIRPython.cmake)
 to automate the production of such files. Finally, a
 `python/mlir/dialects/<dialect-namespace>.py` or a
 `python/mlir/dialects/<dialect-namespace>/__init__.py` file must be created and
 filled with `import`s from the generated files to enable `import
 mlir.dialects.<dialect-namespace>` in Python.
 
 
 ### Attributes and Types
 
 Dialect attributes and types are provided in Python as subclasses of the
 `mlir.ir.Attribute` and `mlir.ir.Type` classes, respectively. Python APIs for

mlir/examples/standalone/python/mlir_standalone/dialects/StandaloneOps.td

 //===-- StandaloneOps.td - Python bindings for standalone --*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_STANDALONE_OPS
 #define PYTHON_BINDINGS_STANDALONE_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "Standalone/StandaloneOps.td"
 
 #endif

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

-//===-- Attributes.td - Attribute mapping for Python -------*- tablegen -*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// This defines the mapping between MLIR ODS attributes and the corresponding
-// Python binding classes.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef PYTHON_BINDINGS_ATTRIBUTES
-#define PYTHON_BINDINGS_ATTRIBUTES
-
-// 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;
-}
-
-#endif

mlir/python/mlir/dialects/ArithOps.td

 //===-- ArithOps.td - Entry point for ArithOps bindings ---------===//
 //
 // 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 PYTHON_BINDINGS_ARITH_OPS
 #define PYTHON_BINDINGS_ARITH_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Arith/IR/ArithOps.td"
 
 #endif

mlir/python/mlir/dialects/AsyncOps.td

 //===-- AsyncOps.td - Entry point async_dialect bindings --*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_ASYNC_OPS
 #define PYTHON_BINDINGS_ASYNC_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Async/IR/AsyncOps.td"
 
 #endif

mlir/python/mlir/dialects/BufferizationOps.td

 //===-- BufferizationOps.td - Entry point for BufferizationOps bindings ---===//
 //
 // 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 PYTHON_BINDINGS_BUFFERIZATION_OPS
 #define PYTHON_BINDINGS_BUFFERIZATION_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Bufferization/IR/BufferizationOps.td"
 
 #endif

mlir/python/mlir/dialects/BufferizationTransformOps.td

 // by the bufferization dialect.
 //
 //===----------------------------------------------------------------------===//
 
 
 #ifndef PYTHON_BINDINGS_BUFFERIZATION_TRANSFORM_OPS
 #define PYTHON_BINDINGS_BUFFERIZATION_TRANSFORM_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Bufferization/TransformOps/BufferizationTransformOps.td"
 
 #endif // PYTHON_BINDINGS_BUFFERIZATION_TRANSFORM_OPS

mlir/python/mlir/dialects/BuiltinOps.td

 //===-- BuiltinOps.td - Entry point for builtin bindings ---*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_BUILTIN_OPS
 #define PYTHON_BINDINGS_BUILTIN_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/IR/BuiltinOps.td"
 
 #endif

mlir/python/mlir/dialects/ComplexOps.td

 //===-- ComplexOps.td - Entry point for ComplexOps bindings ---------------===//
 //
 // 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 PYTHON_BINDINGS_COMPLEX_OPS
 #define PYTHON_BINDINGS_COMPLEX_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Complex/IR/ComplexOps.td"
 
 #endif

mlir/python/mlir/dialects/ControlFlowOps.td

 //===-- ControlFlowOps.td - Python ControlFlowOps bindings -*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_CONTROL_FLOW_OPS
 #define PYTHON_BINDINGS_CONTROL_FLOW_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.td"
 
 #endif

mlir/python/mlir/dialects/FuncOps.td

 //===-- FuncOps.td - Entry point for Func bind -------------*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This is the main file from which the Python bindings for the Func dialect
 // are generated.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef PYTHON_BINDINGS_FUNC
 #define PYTHON_BINDINGS_FUNC
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Func/IR/FuncOps.td"
 
 #endif

mlir/python/mlir/dialects/GPUOps.td

 //===-- GPUOps.td - Entry point GPU_dialect bindings ------*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_GPU_OPS
 #define PYTHON_BINDINGS_GPU_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/GPU/IR/GPUOps.td"
 
 #endif

mlir/python/mlir/dialects/LinalgOps.td

 //===-- LinalgOps.td - Entry point for linalg bind ---------*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_LINALG_OPS
 #define PYTHON_BINDINGS_LINALG_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Linalg/IR/LinalgOps.td"
 include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.td"
 
 #endif

mlir/python/mlir/dialects/LinalgStructuredTransformOps.td

 // provided by Linalg (and other dialects).
 //
 //===----------------------------------------------------------------------===//
 
 
 #ifndef PYTHON_BINDINGS_LINALG_STRUCTURED_TRANSFORM_OPS
 #define PYTHON_BINDINGS_LINALG_STRUCTURED_TRANSFORM_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td"
 
 #endif // PYTHON_BINDINGS_LINALG_STRUCTURED_TRANSFORM_OPS

mlir/python/mlir/dialects/MLProgramOps.td

 //===-- MLProgramOps.td - Entry point for MLProgramOps -----*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_MLPROGRAM_OPS
 #define PYTHON_BINDINGS_MLPROGRAM_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/MLProgram/IR/MLProgramOps.td"
 
 #endif

mlir/python/mlir/dialects/MathOps.td

 //===-- MathOps.td - Entry point for MathOps bindings ------*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_MATH_OPS
 #define PYTHON_BINDINGS_MATH_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Math/IR/MathOps.td"
 
 #endif

mlir/python/mlir/dialects/MemRefOps.td

 //===-- MemRefOps.td - Entry point for MemRefOps bind ------*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_MEMREF_OPS
 #define PYTHON_BINDINGS_MEMREF_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/MemRef/IR/MemRefOps.td"
 
 #endif

mlir/python/mlir/dialects/PDLOps.td

 //===-- PDLOps.td - Entry point for PDLOps bind ------------*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_PDL_OPS
 #define PYTHON_BINDINGS_PDL_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/PDL/IR/PDLOps.td"
 
 #endif

mlir/python/mlir/dialects/SCFLoopTransformOps.td

 // provided by the SCF (and other) dialects.
 //
 //===----------------------------------------------------------------------===//
 
 
 #ifndef PYTHON_BINDINGS_SCF_LOOP_TRANSFORM_OPS
 #define PYTHON_BINDINGS_SCF_LOOP_TRANSFORM_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/SCF/TransformOps/SCFTransformOps.td"
 
 #endif // PYTHON_BINDINGS_SCF_LOOP_TRANSFORM_OPS

mlir/python/mlir/dialects/SCFOps.td

 //===-- SCFOps.td - Entry point for SCF dialect bindings ---*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_SCF_OPS
 #define PYTHON_BINDINGS_SCF_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/SCF/IR/SCFOps.td"
 
 #endif

mlir/python/mlir/dialects/ShapeOps.td

 //===-- ShapeOps.td - Entry point for TensorOps bind -------*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_SHAPE_OPS
 #define PYTHON_BINDINGS_SHAPE_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Shape/IR/ShapeOps.td"
 
 #endif

mlir/python/mlir/dialects/SparseTensorOps.td

 //===-- SparseTensorOps.td - Entry point for bindings ------*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_SPARSE_TENSOR_OPS
 #define PYTHON_BINDINGS_SPARSE_TENSOR_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/SparseTensor/IR/SparseTensorOps.td"
 
 #endif

mlir/python/mlir/dialects/TensorOps.td

 //===-- TensorOps.td - Entry point for TensorOps bind ------*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_TENSOR_OPS
 #define PYTHON_BINDINGS_TENSOR_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Tensor/IR/TensorOps.td"
 
 #endif

mlir/python/mlir/dialects/TosaOps.td

 //===-- TosaOps.td - Entry point for TosaOps bind ----------*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_TOSA_OPS
 #define PYTHON_BINDINGS_TOSA_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Tosa/IR/TosaOps.td"
 
 #endif

mlir/python/mlir/dialects/TransformOps.td

 //===-- TransformOps.td - Transform ops bind entry point ---*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_TRANSFORM_OPS
 #define PYTHON_BINDINGS_TRANSFORM_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Transform/IR/TransformOps.td"
 
 #endif // PYTHON_BINDINGS_TRANSFORM_OPS

mlir/python/mlir/dialects/TransformPDLExtensionOps.td

 //===-- TransformPDLExtensionOps.td - Binding entry point --*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Entry point of the generated Python bindings for the PDL extension of the
 // Transform dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef PYTHON_BINDINGS_TRANSFORM_PDL_EXTENSION_OPS
 #define PYTHON_BINDINGS_TRANSFORM_PDL_EXTENSION_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Transform/PDLExtension/PDLExtensionOps.td"
 
 #endif // PYTHON_BINDINGS_TRANSFORM_PDL_EXTENSION_OPS

mlir/python/mlir/dialects/VectorOps.td

 //===-- VectorOps.td - Entry point for VectorOps bind ------*- tablegen -*-===//
 //
 // 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 PYTHON_BINDINGS_VECTOR_OPS
 #define PYTHON_BINDINGS_VECTOR_OPS
 
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/Dialect/Vector/IR/VectorOps.td"
 
 #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,]

 
 
 // 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_, test_attr, *, optionalF32Attr=None, unitAttr=None, loc=None, ip=None):
+  // CHECK: def __init__(self, i32attr, in_, *, 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 (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 (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 (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, TestAttr:$test_attr);
+                   UnitAttr:$unitAttr, I32Attr:$in);
 }
 
 // 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 (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/test/python/python_test_ops.td

 //===-- python_test_ops.td - Python test Op definitions ----*- tablegen -*-===//
 //
 // 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 PYTHON_TEST_OPS
 #define PYTHON_TEST_OPS
 
 include "mlir/IR/AttrTypeBase.td"
-include "mlir/Bindings/Python/Attributes.td"
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 
 def Python_Test_Dialect : Dialect {
   let name = "python_test";
   let cppNamespace = "python_test";
 
   let useDefaultTypePrinterParser = 1;

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

 /// Template for a suffix when accessing an optional element in the
 /// attribute-sized case:
 ///   {0} is either 'operand' or 'result';
 constexpr const char *opVariadicSegmentOptionalTrailingTemplate =
     R"Py([0] if len({0}_range) > 0 else None)Py";
 
 /// Template for an operation attribute getter:
 ///   {0} is the name of the attribute sanitized for Python;
-///   {1} is the Python type of the attribute;
-///   {2} os the original name of the attribute.
+///   {1} is the original name of the attribute.
 constexpr const char *attributeGetterTemplate = R"Py(
   @builtins.property
   def {0}(self):
-    return {1}(self.operation.attributes["{2}"])
+    return self.operation.attributes["{1}"]
 )Py";
 
 /// Template for an optional operation attribute getter:
 ///   {0} is the name of the attribute sanitized for Python;
-///   {1} is the Python type of the attribute;
-///   {2} is the original name of the attribute.
+///   {1} is the original name of the attribute.
 constexpr const char *optionalAttributeGetterTemplate = R"Py(
   @builtins.property
   def {0}(self):
-    if "{2}" not in self.operation.attributes:
+    if "{1}" not in self.operation.attributes:
       return None
-    return {1}(self.operation.attributes["{2}"])
+    return self.operation.attributes["{1}"]
 )Py";
 
 /// Template for a getter of a unit operation attribute, returns True of the
 /// unit attribute is present, False otherwise (unit attributes have meaning
 /// by mere presence):
 ///    {0} is the name of the attribute sanitized for Python,
 ///    {1} is the original name of the attribute.
 constexpr const char *unitAttributeGetterTemplate = R"Py(
static void emitResultAccessors(const Operator &op, raw_ostream &os) {
   auto getNumVariableLengthResults = [](const Operator &oper) {
     return oper.getNumVariableLengthResults();
   };
   emitElementAccessors(op, os, "result", getNumVariableLengthResults,
                        getNumResults, getResult);
 }
 
 /// Emits accessors to Op attributes.
-static void emitAttributeAccessors(const Operator &op,
-                                   const AttributeClasses &attributeClasses,
-                                   raw_ostream &os) {
+static void emitAttributeAccessors(const Operator &op, raw_ostream &os) {
   for (const auto &namedAttr : op.getAttributes()) {
     // Skip "derived" attributes because they are just C++ functions that we
     // don't currently expose.
     if (namedAttr.attr.isDerivedAttr())
       continue;
 
     if (namedAttr.name.empty())
       continue;
 
     std::string sanitizedName = sanitizeName(namedAttr.name);
 
     // Unit attributes are handled specially.
     if (namedAttr.attr.getStorageType().trim().equals("::mlir::UnitAttr")) {
       os << llvm::formatv(unitAttributeGetterTemplate, sanitizedName,
                           namedAttr.name);
       os << llvm::formatv(unitAttributeSetterTemplate, sanitizedName,
                           namedAttr.name);
       os << llvm::formatv(attributeDeleterTemplate, sanitizedName,
                           namedAttr.name);
       continue;
     }
 
-    StringRef pythonType =
-        attributeClasses.lookup(namedAttr.attr.getStorageType());
     if (namedAttr.attr.isOptional()) {
       os << llvm::formatv(optionalAttributeGetterTemplate, sanitizedName,
-                          pythonType, namedAttr.name);
+                          namedAttr.name);
       os << llvm::formatv(optionalAttributeSetterTemplate, sanitizedName,
                           namedAttr.name);
       os << llvm::formatv(attributeDeleterTemplate, sanitizedName,
                           namedAttr.name);
     } else {
-      os << llvm::formatv(attributeGetterTemplate, sanitizedName, pythonType,
+      os << llvm::formatv(attributeGetterTemplate, sanitizedName,
                           namedAttr.name);
       os << llvm::formatv(attributeSetterTemplate, sanitizedName,
                           namedAttr.name);
       // Non-optional attributes cannot be deleted.
     }
   }
 }
 
for (size_t i = 0, cnt = builderArgs.size(); i < cnt; ++i) {
     }
   }
   functionArgs.push_back("loc=None");
   functionArgs.push_back("ip=None");
   os << llvm::formatv(initTemplate, llvm::join(functionArgs, ", "),
                       llvm::join(builderLines, "\n    "));
 }
 
-static void constructAttributeMapping(const llvm::RecordKeeper &records,
-                                      AttributeClasses &attributeClasses) {
-  for (const llvm::Record *rec :
-       records.getAllDerivedDefinitions("PythonAttr")) {
-    attributeClasses.try_emplace(rec->getValueAsString("cppStorageType").trim(),
-                                 rec->getValueAsString("pythonType").trim());
-  }
-}
-
 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) {
   std::string segmentSpec("[");
   for (int i = 0, e = getNumElements(op); i < e; ++i) {
assert((!region.isVariadic() || en.index() == op.getNumRegions() - 1) &&
            "expected only the last region to be variadic");
     os << llvm::formatv(regionAccessorTemplate, sanitizeName(region.name),
                         std::to_string(en.index()) +
                             (region.isVariadic() ? ":" : ""));
   }
 }
 
 /// Emits bindings for a specific Op to the given output stream.
-static void emitOpBindings(const Operator &op,
-                           const AttributeClasses &attributeClasses,
-                           raw_ostream &os) {
+static void emitOpBindings(const Operator &op, raw_ostream &os) {
   os << llvm::formatv(opClassTemplate, op.getCppClassName(),
                       op.getOperationName());
 
   // Sized segments.
   if (op.getTrait(attrSizedTraitForKind("operand")) != nullptr) {
     emitSegmentSpec(op, "OPERAND", getNumOperands, getOperand, os);
   }
   if (op.getTrait(attrSizedTraitForKind("result")) != nullptr) {
     emitSegmentSpec(op, "RESULT", getNumResults, getResult, os);
   }
 
   emitRegionAttributes(op, os);
   emitDefaultOpBuilder(op, os);
   emitOperandAccessors(op, os);
-  emitAttributeAccessors(op, attributeClasses, os);
+  emitAttributeAccessors(op, os);
   emitResultAccessors(op, os);
   emitRegionAccessors(op, os);
 }
 
 /// Emits bindings for the dialect specified in the command line, including file
 /// headers and utilities. Returns `false` on success to comply with Tablegen
 /// registration requirements.
 static bool emitAllOps(const llvm::RecordKeeper &records, raw_ostream &os) {
   if (clDialectName.empty())
     llvm::PrintFatalError("dialect name not provided");
 
-  AttributeClasses attributeClasses;
-  constructAttributeMapping(records, attributeClasses);
-
   bool isExtension = !clDialectExtensionName.empty();
   os << llvm::formatv(fileHeader, isExtension
                                       ? clDialectExtensionName.getValue()
                                       : clDialectName.getValue());
   if (isExtension)
     os << llvm::formatv(dialectExtensionTemplate, clDialectName.getValue());
   else
     os << llvm::formatv(dialectClassTemplate, clDialectName.getValue());
 
   for (const llvm::Record *rec : records.getAllDerivedDefinitions("Op")) {
     Operator op(rec);
     if (op.getDialectName() == clDialectName.getValue())
-      emitOpBindings(op, attributeClasses, os);
+      emitOpBindings(op, os);
   }
   return false;
 }
 
 static GenRegistration
     genPythonBindings("gen-python-op-bindings",
                       "Generate Python bindings for MLIR Ops", &emitAllOps);