[mlir][python] Aggressively avoid name collisions in generated python ODS code.

[stellaraccident]

Summary

• When porting npcomp to use these bindings, I ran into enough patterns of collisions that I decided to be somewhat draconian about not polluting the namespace.
• With these changes all of the npcomp dialects generate and pass what tests we have.

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", "_ir.Attribute">;
-def : PythonAttr<"::mlir::BoolAttr", "_ir.BoolAttr">;
-def : PythonAttr<"::mlir::IntegerAttr", "_ir.IntegerAttr">;
-def : PythonAttr<"::mlir::FloatAttr", "_ir.FloatAttr">;
-def : PythonAttr<"::mlir::StringAttr", "_ir.StringAttr">;
-def : PythonAttr<"::mlir::DenseElementsAttr", "_ir.DenseElementsAttr">;
-def : PythonAttr<"::mlir::DenseIntElementsAttr", "_ir.DenseIntElementsAttr">;
-def : PythonAttr<"::mlir::DenseFPElementsAttr", "_ir.DenseFPElementsAttr">;
+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/Bindings/Python/Attributes.td"
 
-// CHECK: @_cext.register_dialect
-// CHECK: class _Dialect(_ir.Dialect):
+// 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";
 }
 class TestOp<string mnemonic, list<OpTrait> traits = []> :
     Op<Test_Dialect, mnemonic, traits>;
 
-// CHECK: @_cext.register_operation(_Dialect)
-// CHECK: class AttrSizedOperandsOp(_ir.OpView):
+// CHECK: @_ods_cext.register_operation(_Dialect)
+// CHECK: class AttrSizedOperandsOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.attr_sized_operands"
 def AttrSizedOperandsOp : TestOp<"attr_sized_operands",
                                  [AttrSizedOperandSegments]> {
   // CHECK: def __init__(self, variadic1, non_variadic, variadic2, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
-  // CHECK:   operand_segment_sizes = array.array('L')
+  // CHECK:   operand_segment_sizes_ods = _ods_array.array('L')
   // CHECK:   operands += [*variadic1]
-  // CHECK:   operand_segment_sizes.append(len(variadic1))
+  // CHECK:   operand_segment_sizes_ods.append(len(variadic1))
   // CHECK:   operands.append(non_variadic)
-  // CHECK:   operand_segment_sizes.append(1)
+  // CHECK:   operand_segment_sizes_ods.append(1)
   // CHECK:   if variadic2 is not None: operands.append(variadic2)
-  // CHECK:   operand_segment_sizes.append(0 if variadic2 is None else 1)
-  // CHECK:   attributes["operand_segment_sizes"] = _ir.DenseElementsAttr.get(operand_segment_sizes,
-  // CHECK:       context=_get_default_loc_context(loc))
-  // CHECK:   super().__init__(_ir.Operation.create(
+  // CHECK:   operand_segment_sizes_ods.append(0 if variadic2 is None else 1)
+  // CHECK:   attributes["operand_segment_sizes"] = _ods_ir.DenseElementsAttr.get(operand_segment_sizes_ods,
+  // CHECK:       context=_ods_get_default_loc_context(loc))
+  // CHECK:   super().__init__(_ods_ir.Operation.create(
   // CHECK:     "test.attr_sized_operands", attributes=attributes, operands=operands, results=results,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def variadic1(self):
-  // CHECK:   operand_range = _segmented_accessor(
+  // CHECK:   operand_range = _ods_segmented_accessor(
   // CHECK:       self.operation.operands,
   // CHECK:       self.operation.attributes["operand_segment_sizes"], 0)
   // CHECK:   return operand_range
   //
   // CHECK: @property
   // CHECK: def non_variadic(self):
-  // CHECK:   operand_range = _segmented_accessor(
+  // CHECK:   operand_range = _ods_segmented_accessor(
   // CHECK:       self.operation.operands,
   // CHECK:       self.operation.attributes["operand_segment_sizes"], 1)
   // CHECK:   return operand_range[0]
   //
   // CHECK: @property
   // CHECK: def variadic2(self):
-  // CHECK:   operand_range = _segmented_accessor(
+  // CHECK:   operand_range = _ods_segmented_accessor(
   // CHECK:       self.operation.operands,
   // CHECK:       self.operation.attributes["operand_segment_sizes"], 2)
   // CHECK:   return operand_range[0] if len(operand_range) > 0 else None
   let arguments = (ins Variadic<AnyType>:$variadic1, AnyType:$non_variadic,
                    Optional<AnyType>:$variadic2);
 }
 
-// CHECK: @_cext.register_operation(_Dialect)
-// CHECK: class AttrSizedResultsOp(_ir.OpView):
+// CHECK: @_ods_cext.register_operation(_Dialect)
+// CHECK: class AttrSizedResultsOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.attr_sized_results"
 def AttrSizedResultsOp : TestOp<"attr_sized_results",
                                [AttrSizedResultSegments]> {
   // CHECK: def __init__(self, variadic1, non_variadic, variadic2, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
-  // CHECK:   result_segment_sizes = array.array('L')
+  // CHECK:   result_segment_sizes_ods = _ods_array.array('L')
   // CHECK:   if variadic1 is not None: results.append(variadic1)
-  // CHECK:   result_segment_sizes.append(0 if variadic1 is None else 1)
+  // CHECK:   result_segment_sizes_ods.append(0 if variadic1 is None else 1)
   // CHECK:   results.append(non_variadic)
-  // CHECK:   result_segment_sizes.append(1) # non_variadic
+  // CHECK:   result_segment_sizes_ods.append(1) # non_variadic
   // CHECK:   if variadic2 is not None: results.append(variadic2)
-  // CHECK:   result_segment_sizes.append(0 if variadic2 is None else 1)
-  // CHECK:   attributes["result_segment_sizes"] = _ir.DenseElementsAttr.get(result_segment_sizes,
-  // CHECK:       context=_get_default_loc_context(loc))
-  // CHECK:   super().__init__(_ir.Operation.create(
+  // CHECK:   result_segment_sizes_ods.append(0 if variadic2 is None else 1)
+  // CHECK:   attributes["result_segment_sizes"] = _ods_ir.DenseElementsAttr.get(result_segment_sizes_ods,
+  // CHECK:       context=_ods_get_default_loc_context(loc))
+  // CHECK:   super().__init__(_ods_ir.Operation.create(
   // CHECK:     "test.attr_sized_results", attributes=attributes, operands=operands, results=results,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def variadic1(self):
-  // CHECK:   result_range = _segmented_accessor(
+  // CHECK:   result_range = _ods_segmented_accessor(
   // CHECK:       self.operation.results,
   // CHECK:       self.operation.attributes["result_segment_sizes"], 0)
   // CHECK:   return result_range[0] if len(result_range) > 0 else None
   //
   // CHECK: @property
   // CHECK: def non_variadic(self):
-  // CHECK:   result_range = _segmented_accessor(
+  // CHECK:   result_range = _ods_segmented_accessor(
   // CHECK:       self.operation.results,
   // CHECK:       self.operation.attributes["result_segment_sizes"], 1)
   // CHECK:   return result_range[0]
   //
   // CHECK: @property
   // CHECK: def variadic2(self):
-  // CHECK:   result_range = _segmented_accessor(
+  // CHECK:   result_range = _ods_segmented_accessor(
   // CHECK:       self.operation.results,
   // CHECK:       self.operation.attributes["result_segment_sizes"], 2)
   // CHECK:   return result_range
   let results = (outs Optional<AnyType>:$variadic1, AnyType:$non_variadic,
                  Optional<AnyType>:$variadic2);
 }
 
 
-// CHECK: @_cext.register_operation(_Dialect)
-// CHECK: class AttributedOp(_ir.OpView):
+// CHECK: @_ods_cext.register_operation(_Dialect)
+// CHECK: class AttributedOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.attributed_op"
 def AttributedOp : TestOp<"attributed_op"> {
   // CHECK: def __init__(self, i32attr, optionalF32Attr, unitAttr, in_, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   attributes["i32attr"] = i32attr
   // CHECK:   if optionalF32Attr is not None: attributes["optionalF32Attr"] = optionalF32Attr
-  // CHECK:   if bool(unitAttr): attributes["unitAttr"] = _ir.UnitAttr.get(
-  // CHECK:     _get_default_loc_context(loc))
+  // CHECK:   if bool(unitAttr): attributes["unitAttr"] = _ods_ir.UnitAttr.get(
+  // CHECK:     _ods_get_default_loc_context(loc))
   // CHECK:   attributes["in"] = in_
-  // CHECK:   super().__init__(_ir.Operation.create(
+  // CHECK:   super().__init__(_ods_ir.Operation.create(
   // CHECK:     "test.attributed_op", attributes=attributes, operands=operands, results=results,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def i32attr(self):
-  // CHECK:   return _ir.IntegerAttr(self.operation.attributes["i32attr"])
+  // CHECK:   return _ods_ir.IntegerAttr(self.operation.attributes["i32attr"])
 
   // CHECK: @property
   // CHECK: def optionalF32Attr(self):
   // CHECK:   if "optionalF32Attr" not in self.operation.attributes:
   // CHECK:     return None
-  // CHECK:   return _ir.FloatAttr(self.operation.attributes["optionalF32Attr"])
+  // CHECK:   return _ods_ir.FloatAttr(self.operation.attributes["optionalF32Attr"])
 
   // CHECK: @property
   // CHECK: def unitAttr(self):
   // CHECK:   return "unitAttr" in self.operation.attributes
 
   // CHECK: @property
   // CHECK: def in_(self):
-  // CHECK:   return _ir.IntegerAttr(self.operation.attributes["in"])
+  // CHECK:   return _ods_ir.IntegerAttr(self.operation.attributes["in"])
   let arguments = (ins I32Attr:$i32attr, OptionalAttr<F32Attr>:$optionalF32Attr,
                    UnitAttr:$unitAttr, I32Attr:$in);
 }
 
-// CHECK: @_cext.register_operation(_Dialect)
-// CHECK: class AttributedOpWithOperands(_ir.OpView):
+// CHECK: @_ods_cext.register_operation(_Dialect)
+// CHECK: class AttributedOpWithOperands(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.attributed_op_with_operands"
 def AttributedOpWithOperands : TestOp<"attributed_op_with_operands"> {
   // CHECK: def __init__(self, _gen_arg_0, in_, _gen_arg_2, is_, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   operands.append(_gen_arg_0)
   // CHECK:   operands.append(_gen_arg_2)
-  // CHECK:   if bool(in_): attributes["in"] = _ir.UnitAttr.get(
-  // CHECK:     _get_default_loc_context(loc))
+  // CHECK:   if bool(in_): attributes["in"] = _ods_ir.UnitAttr.get(
+  // CHECK:     _ods_get_default_loc_context(loc))
   // CHECK:   if is_ is not None: attributes["is"] = is_
-  // CHECK:   super().__init__(_ir.Operation.create(
+  // CHECK:   super().__init__(_ods_ir.Operation.create(
   // CHECK:     "test.attributed_op_with_operands", attributes=attributes, operands=operands, results=results,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def in_(self):
   // CHECK:   return "in" in self.operation.attributes
 
   // CHECK: @property
   // CHECK: def is_(self):
   // CHECK:   if "is" not in self.operation.attributes:
   // CHECK:     return None
-  // CHECK:   return _ir.FloatAttr(self.operation.attributes["is"])
+  // CHECK:   return _ods_ir.FloatAttr(self.operation.attributes["is"])
   let arguments = (ins I32, UnitAttr:$in, F32, OptionalAttr<F32Attr>:$is);
 }
 
 
-// CHECK: @_cext.register_operation(_Dialect)
-// CHECK: class EmptyOp(_ir.OpView):
+// CHECK: @_ods_cext.register_operation(_Dialect)
+// CHECK: class EmptyOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.empty"
 def EmptyOp : TestOp<"empty">;
   // CHECK: def __init__(self, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
-  // CHECK:   super().__init__(_ir.Operation.create(
+  // CHECK:   super().__init__(_ods_ir.Operation.create(
   // CHECK:     "test.empty", attributes=attributes, operands=operands, results=results,
   // CHECK:     loc=loc, ip=ip))
 
-// CHECK: @_cext.register_operation(_Dialect)
-// CHECK: class MissingNamesOp(_ir.OpView):
+// CHECK: @_ods_cext.register_operation(_Dialect)
+// CHECK: class MissingNamesOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.missing_names"
 def MissingNamesOp : TestOp<"missing_names"> {
   // CHECK: def __init__(self, i32, _gen_res_1, i64, _gen_arg_0, f32, _gen_arg_2, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   results.append(i32)
   // CHECK:   results.append(_gen_res_1)
   // CHECK:   results.append(i64)
   // CHECK:   operands.append(_gen_arg_0)
   // CHECK:   operands.append(f32)
   // CHECK:   operands.append(_gen_arg_2)
-  // CHECK:   super().__init__(_ir.Operation.create(
+  // CHECK:   super().__init__(_ods_ir.Operation.create(
   // CHECK:     "test.missing_names", attributes=attributes, operands=operands, results=results,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def f32(self):
   // CHECK:   return self.operation.operands[1]
   let arguments = (ins I32, F32:$f32, I64);
 
   // CHECK: @property
   // CHECK: def i32(self):
   // CHECK:   return self.operation.results[0]
   //
   // CHECK: @property
   // CHECK: def i64(self):
   // CHECK:   return self.operation.results[2]
   let results = (outs I32:$i32, F32, I64:$i64);
 }
 
-// CHECK: @_cext.register_operation(_Dialect)
-// CHECK: class OneVariadicOperandOp(_ir.OpView):
+// CHECK: @_ods_cext.register_operation(_Dialect)
+// CHECK: class OneVariadicOperandOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.one_variadic_operand"
 def OneVariadicOperandOp : TestOp<"one_variadic_operand"> {
   // CHECK: def __init__(self, non_variadic, variadic, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   operands.append(non_variadic)
   // CHECK:   operands += [*variadic]
-  // CHECK:   super().__init__(_ir.Operation.create(
+  // CHECK:   super().__init__(_ods_ir.Operation.create(
   // CHECK:     "test.one_variadic_operand", attributes=attributes, operands=operands, results=results,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def non_variadic(self):
   // CHECK:   return self.operation.operands[0]
   //
   // CHECK: @property
   // CHECK: def variadic(self):
-  // CHECK:   variadic_group_length = len(self.operation.operands) - 2 + 1
-  // CHECK:   return self.operation.operands[1:1 + variadic_group_length]
+  // CHECK:   _ods_variadic_group_length = len(self.operation.operands) - 2 + 1
+  // CHECK:   return self.operation.operands[1:1 + _ods_variadic_group_length]
   let arguments = (ins AnyType:$non_variadic, Variadic<AnyType>:$variadic);
 }
 
-// CHECK: @_cext.register_operation(_Dialect)
-// CHECK: class OneVariadicResultOp(_ir.OpView):
+// CHECK: @_ods_cext.register_operation(_Dialect)
+// CHECK: class OneVariadicResultOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.one_variadic_result"
 def OneVariadicResultOp : TestOp<"one_variadic_result"> {
   // CHECK: def __init__(self, variadic, non_variadic, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   results += [*variadic]
   // CHECK:   results.append(non_variadic)
-  // CHECK:   super().__init__(_ir.Operation.create(
+  // CHECK:   super().__init__(_ods_ir.Operation.create(
   // CHECK:     "test.one_variadic_result", attributes=attributes, operands=operands, results=results,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def variadic(self):
-  // CHECK:   variadic_group_length = len(self.operation.results) - 2 + 1
-  // CHECK:   return self.operation.results[0:0 + variadic_group_length]
+  // CHECK:   _ods_variadic_group_length = len(self.operation.results) - 2 + 1
+  // CHECK:   return self.operation.results[0:0 + _ods_variadic_group_length]
   //
   // CHECK: @property
   // CHECK: def non_variadic(self):
-  // CHECK:   variadic_group_length = len(self.operation.results) - 2 + 1
-  // CHECK:   return self.operation.results[1 + variadic_group_length - 1]
+  // CHECK:   _ods_variadic_group_length = len(self.operation.results) - 2 + 1
+  // CHECK:   return self.operation.results[1 + _ods_variadic_group_length - 1]
   let results = (outs Variadic<AnyType>:$variadic, AnyType:$non_variadic);
 }
 
-// CHECK: @_cext.register_operation(_Dialect)
-// CHECK: class PythonKeywordOp(_ir.OpView):
+// CHECK: @_ods_cext.register_operation(_Dialect)
+// CHECK: class PythonKeywordOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.python_keyword"
 def PythonKeywordOp : TestOp<"python_keyword"> {
   // CHECK: def __init__(self, in_, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   operands.append(in_)
-  // CHECK:   super().__init__(_ir.Operation.create(
+  // CHECK:   super().__init__(_ods_ir.Operation.create(
   // CHECK:     "test.python_keyword", attributes=attributes, operands=operands, results=results,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def in_(self):
   // CHECK:   return self.operation.operands[0]
   let arguments = (ins AnyType:$in);
 }
 
-// CHECK: @_cext.register_operation(_Dialect)
-// CHECK: class SameVariadicOperandSizeOp(_ir.OpView):
+// CHECK: @_ods_cext.register_operation(_Dialect)
+// CHECK: class SameVariadicOperandSizeOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.same_variadic_operand"
 def SameVariadicOperandSizeOp : TestOp<"same_variadic_operand",
                                        [SameVariadicOperandSize]> {
   // CHECK: @property
   // CHECK: def variadic1(self):
-  // CHECK:   start, pg = _equally_sized_accessor(operation.operands, 2, 0, 0)
+  // CHECK:   start, pg = _ods_equally_sized_accessor(operation.operands, 2, 0, 0)
   // CHECK:   return self.operation.operands[start:start + pg]
   //
   // CHECK: @property
   // CHECK: def non_variadic(self):
-  // CHECK:   start, pg = _equally_sized_accessor(operation.operands, 2, 0, 1)
+  // CHECK:   start, pg = _ods_equally_sized_accessor(operation.operands, 2, 0, 1)
   // CHECK:   return self.operation.operands[start]
   //
   // CHECK: @property
   // CHECK: def variadic2(self):
-  // CHECK:   start, pg = _equally_sized_accessor(operation.operands, 2, 1, 1)
+  // CHECK:   start, pg = _ods_equally_sized_accessor(operation.operands, 2, 1, 1)
   // CHECK:   return self.operation.operands[start:start + pg]
   let arguments = (ins Variadic<AnyType>:$variadic1, AnyType:$non_variadic,
                    Variadic<AnyType>:$variadic2);
 }
 
-// CHECK: @_cext.register_operation(_Dialect)
-// CHECK: class SameVariadicResultSizeOp(_ir.OpView):
+// CHECK: @_ods_cext.register_operation(_Dialect)
+// CHECK: class SameVariadicResultSizeOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.same_variadic_result"
 def SameVariadicResultSizeOp : TestOp<"same_variadic_result",
                                       [SameVariadicResultSize]> {
   // CHECK: @property
   // CHECK: def variadic1(self):
-  // CHECK:   start, pg = _equally_sized_accessor(operation.results, 2, 0, 0)
+  // CHECK:   start, pg = _ods_equally_sized_accessor(operation.results, 2, 0, 0)
   // CHECK:   return self.operation.results[start:start + pg]
   //
   // CHECK: @property
   // CHECK: def non_variadic(self):
-  // CHECK:   start, pg = _equally_sized_accessor(operation.results, 2, 0, 1)
+  // CHECK:   start, pg = _ods_equally_sized_accessor(operation.results, 2, 0, 1)
   // CHECK:   return self.operation.results[start]
   //
   // CHECK: @property
   // CHECK: def variadic2(self):
-  // CHECK:   start, pg = _equally_sized_accessor(operation.results, 2, 1, 1)
+  // CHECK:   start, pg = _ods_equally_sized_accessor(operation.results, 2, 1, 1)
   // CHECK:   return self.operation.results[start:start + pg]
   let results = (outs Variadic<AnyType>:$variadic1, AnyType:$non_variadic,
                  Variadic<AnyType>:$variadic2);
 }
 
-// CHECK: @_cext.register_operation(_Dialect)
-// CHECK: class SimpleOp(_ir.OpView):
+// CHECK: @_ods_cext.register_operation(_Dialect)
+// CHECK: class SimpleOp(_ods_ir.OpView):
 // CHECK-LABEL: OPERATION_NAME = "test.simple"
 def SimpleOp : TestOp<"simple"> {
   // CHECK: def __init__(self, i64, f64, i32, f32, loc=None, ip=None):
   // CHECK:   operands = []
   // CHECK:   results = []
   // CHECK:   attributes = {}
   // CHECK:   results.append(i64)
   // CHECK:   results.append(f64)
   // CHECK:   operands.append(i32)
   // CHECK:   operands.append(f32)
-  // CHECK:   super().__init__(_ir.Operation.create(
+  // CHECK:   super().__init__(_ods_ir.Operation.create(
   // CHECK:     "test.simple", attributes=attributes, operands=operands, results=results,
   // CHECK:     loc=loc, ip=ip))
 
   // CHECK: @property
   // CHECK: def i32(self):
   // CHECK:   return self.operation.operands[0]
   //
   // CHECK: @property

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

 
 using namespace mlir;
 using namespace mlir::tblgen;
 
 /// File header and includes.
 constexpr const char *fileHeader = R"Py(
 # Autogenerated by mlir-tblgen; don't manually edit.
 
-import array
-from . import _cext
-from . import _segmented_accessor, _equally_sized_accessor, _get_default_loc_context
-_ir = _cext.ir
+import array as _ods_array
+from . import _cext as _ods_cext
+from . import _segmented_accessor as _ods_segmented_accessor, _equally_sized_accessor as _ods_equally_sized_accessor, _get_default_loc_context as _ods_get_default_loc_context
+_ods_ir = _ods_cext.ir
 )Py";
 
 /// Template for dialect class:
 ///   {0} is the dialect namespace.
 constexpr const char *dialectClassTemplate = R"Py(
-@_cext.register_dialect
-class _Dialect(_ir.Dialect):
+@_ods_cext.register_dialect
+class _Dialect(_ods_ir.Dialect):
   DIALECT_NAMESPACE = "{0}"
   pass
 
 )Py";
 
 /// Template for operation class:
 ///   {0} is the Python class name;
 ///   {1} is the operation name.
 constexpr const char *opClassTemplate = R"Py(
-@_cext.register_operation(_Dialect)
-class {0}(_ir.OpView):
+@_ods_cext.register_operation(_Dialect)
+class {0}(_ods_ir.OpView):
   OPERATION_NAME = "{1}"
 )Py";
 
 /// Template for single-element accessor:
 ///   {0} is the name of the accessor;
 ///   {1} is either 'operand' or 'result';
 ///   {2} is the position in the element list.
 constexpr const char *opSingleTemplate = R"Py(
   @property
   def {0}(self):
     return self.operation.{1}s[{2}]
 )Py";
 
 /// Template for single-element accessor after a variable-length group:
 ///   {0} is the name of the accessor;
 ///   {1} is either 'operand' or 'result';
 ///   {2} is the total number of element groups;
 ///   {3} is the position of the current group in the group list.
 /// This works for both a single variadic group (non-negative length) and an
 /// single optional element (zero length if the element is absent).
 constexpr const char *opSingleAfterVariableTemplate = R"Py(
   @property
   def {0}(self):
-    variadic_group_length = len(self.operation.{1}s) - {2} + 1
-    return self.operation.{1}s[{3} + variadic_group_length - 1]
+    _ods_variadic_group_length = len(self.operation.{1}s) - {2} + 1
+    return self.operation.{1}s[{3} + _ods_variadic_group_length - 1]
 )Py";
 
 /// Template for an optional element accessor:
 ///   {0} is the name of the accessor;
 ///   {1} is either 'operand' or 'result';
 ///   {2} is the total number of element groups;
 ///   {3} is the position of the current group in the group list.
 constexpr const char *opOneOptionalTemplate = R"Py(
   @property
   def {0}(self);
     return self.operation.{1}s[{3}] if len(self.operation.{1}s) > {2}
                                     else None
 )Py";
 
 /// Template for the variadic group accessor in the single variadic group case:
 ///   {0} is the name of the accessor;
 ///   {1} is either 'operand' or 'result';
 ///   {2} is the total number of element groups;
 ///   {3} is the position of the current group in the group list.
 constexpr const char *opOneVariadicTemplate = R"Py(
   @property
   def {0}(self):
-    variadic_group_length = len(self.operation.{1}s) - {2} + 1
-    return self.operation.{1}s[{3}:{3} + variadic_group_length]
+    _ods_variadic_group_length = len(self.operation.{1}s) - {2} + 1
+    return self.operation.{1}s[{3}:{3} + _ods_variadic_group_length]
 )Py";
 
 /// First part of the template for equally-sized variadic group accessor:
 ///   {0} is the name of the accessor;
 ///   {1} is either 'operand' or 'result';
 ///   {2} is the total number of variadic groups;
 ///   {3} is the number of non-variadic groups preceding the current group;
 ///   {3} is the number of variadic groups preceding the current group.
 constexpr const char *opVariadicEqualPrefixTemplate = R"Py(
   @property
   def {0}(self):
-    start, pg = _equally_sized_accessor(operation.{1}s, {2}, {3}, {4}))Py";
+    start, pg = _ods_equally_sized_accessor(operation.{1}s, {2}, {3}, {4}))Py";
 
 /// Second part of the template for equally-sized case, accessing a single
 /// element:
 ///   {0} is either 'operand' or 'result'.
 constexpr const char *opVariadicEqualSimpleTemplate = R"Py(
     return self.operation.{0}s[start]
 )Py";
 
 /// Second part of the template for equally-sized case, accessing a variadic
 /// group:
 ///   {0} is either 'operand' or 'result'.
 constexpr const char *opVariadicEqualVariadicTemplate = R"Py(
     return self.operation.{0}s[start:start + pg]
 )Py";
 
 /// Template for an attribute-sized group accessor:
 ///   {0} is the name of the accessor;
 ///   {1} is either 'operand' or 'result';
 ///   {2} is the position of the group in the group list;
 ///   {3} is a return suffix (expected [0] for single-element, empty for
 ///       variadic, and opVariadicSegmentOptionalTrailingTemplate for optional).
 constexpr const char *opVariadicSegmentTemplate = R"Py(
   @property
   def {0}(self):
-    {1}_range = _segmented_accessor(
+    {1}_range = _ods_segmented_accessor(
          self.operation.{1}s,
          self.operation.attributes["{1}_segment_sizes"], {2})
     return {1}_range{3}
 )Py";
 
 /// Template for a suffix when accessing an optional element in the
 /// attribute-sized case:
 ///   {0} is either 'operand' or 'result';

 /// Template for a setter of a unit operation attribute, setting to None or
 /// False removes the attribute:
 ///    {0} is the name of the attribute sanitized for Python;
 ///    {1} is the original name of the attribute.
 constexpr const char *unitAttributeSetterTemplate = R"Py(
   @{0}.setter
   def {0}(self, value):
     if bool(value):
-      self.operation.attributes["{1}"] = _ir.UnitAttr.get()
+      self.operation.attributes["{1}"] = _ods_ir.UnitAttr.get()
     elif "{1}" in self.operation.attributes:
       del self.operation.attributes["{1}"]
 )Py";
 
 /// Template for a deleter of an optional or a unit operation attribute, removes
 /// the attribute from the operation:
 ///    {0} is the name of the attribute sanitized for Python;
 ///    {1} is the original name of the attribute.
static llvm::StringSet<> keywords(
       {"and",   "as",     "assert",   "break", "class",  "continue",
        "def",   "del",    "elif",     "else",  "except", "finally",
        "for",   "from",   "global",   "if",    "import", "in",
        "is",    "lambda", "nonlocal", "not",   "or",     "pass",
        "raise", "return", "try",      "while", "with",   "yield"});
   return keywords.contains(str);
 };
 
+/// Checks whether `str` would shadow a generated variable or attribute
+/// part of the OpView API.
+static bool isODSReserved(StringRef str) {
+  static llvm::StringSet<> reserved(
+      {"attributes", "create", "context", "ip", "operands", "print", "get_asm",
+       "loc", "verify", "regions", "result", "results", "self", "operation",
+       "DIALECT_NAMESPACE", "OPERATION_NAME"});
+  return str.startswith("_ods_") || str.endswith("_ods") ||
+         reserved.contains(str);
+}
+
 /// Modifies the `name` in a way that it becomes suitable for Python bindings
 /// (does not change the `name` if it already is suitable) and returns the
 /// modified version.
 static std::string sanitizeName(StringRef name) {
-  if (isPythonKeyword(name))
+  if (isPythonKeyword(name) || isODSReserved(name))
     return (name + "_").str();
   return name.str();
 }
 
 static std::string attrSizedTraitForKind(const char *kind) {
   return llvm::formatv("::mlir::OpTrait::AttrSized{0}{1}Segments",
                        llvm::StringRef(kind).take_front().upper(),
                        llvm::StringRef(kind).drop_front());

 ///       `loc` and `ip`;
 ///   {2} is the code populating `operands`, `results` and `attributes` fields.
 constexpr const char *initTemplate = R"Py(
   def __init__(self, {1}):
     operands = []
     results = []
     attributes = {{}
     {2}
-    super().__init__(_ir.Operation.create(
+    super().__init__(_ods_ir.Operation.create(
       "{0}", attributes=attributes, operands=operands, results=results,
       loc=loc, ip=ip))
 )Py";
 
 /// Template for appending a single element to the operand/result list.
 ///   {0} is either 'operand' or 'result';
 ///   {1} is the field name.
 constexpr const char *singleElementAppendTemplate = "{0}s.append({1})";
 
 /// Template for appending an optional element to the operand/result list.
 ///   {0} is either 'operand' or 'result';
 ///   {1} is the field name.
 constexpr const char *optionalAppendTemplate =
     "if {1} is not None: {0}s.append({1})";
 
 /// Template for appending a variadic element to the operand/result list.
 ///   {0} is either 'operand' or 'result';
 ///   {1} is the field name.
 constexpr const char *variadicAppendTemplate = "{0}s += [*{1}]";
 
 /// Template for setting up the segment sizes buffer.
 constexpr const char *segmentDeclarationTemplate =
-    "{0}_segment_sizes = array.array('L')";
+    "{0}_segment_sizes_ods = _ods_array.array('L')";
 
 /// Template for attaching segment sizes to the attribute list.
 constexpr const char *segmentAttributeTemplate =
-    R"Py(attributes["{0}_segment_sizes"] = _ir.DenseElementsAttr.get({0}_segment_sizes,
-      context=_get_default_loc_context(loc)))Py";
+    R"Py(attributes["{0}_segment_sizes"] = _ods_ir.DenseElementsAttr.get({0}_segment_sizes_ods,
+      context=_ods_get_default_loc_context(loc)))Py";
 
 /// Template for appending the unit size to the segment sizes.
 ///   {0} is either 'operand' or 'result';
 ///   {1} is the field name.
 constexpr const char *singleElementSegmentTemplate =
-    "{0}_segment_sizes.append(1) # {1}";
+    "{0}_segment_sizes_ods.append(1) # {1}";
 
 /// Template for appending 0/1 for an optional element to the segment sizes.
 ///   {0} is either 'operand' or 'result';
 ///   {1} is the field name.
 constexpr const char *optionalSegmentTemplate =
-    "{0}_segment_sizes.append(0 if {1} is None else 1)";
+    "{0}_segment_sizes_ods.append(0 if {1} is None else 1)";
 
 /// Template for appending the length of a variadic group to the segment sizes.
 ///   {0} is either 'operand' or 'result';
 ///   {1} is the field name.
 constexpr const char *variadicSegmentTemplate =
-    "{0}_segment_sizes.append(len({1}))";
+    "{0}_segment_sizes_ods.append(len({1}))";
 
 /// Template for setting an attribute in the operation builder.
 ///   {0} is the attribute name;
 ///   {1} is the builder argument name.
 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";
 
 constexpr const char *initUnitAttributeTemplate =
-    R"Py(if bool({1}): attributes["{0}"] = _ir.UnitAttr.get(
-      _get_default_loc_context(loc)))Py";
+    R"Py(if bool({1}): attributes["{0}"] = _ods_ir.UnitAttr.get(
+      _ods_get_default_loc_context(loc)))Py";
 
 /// Populates `builderArgs` with the Python-compatible names of builder function
 /// arguments, first the results, then the intermixed attributes and operands in
 /// the same order as they appear in the `arguments` field of the op definition.
 /// Additionally, `operandNames` is populated with names of operands in their
 /// order of appearance.
 static void
 populateBuilderArgs(const Operator &op,