Skip to content

Test

test

Test = Dialect('test', [TestOp, TestPureOp, TestReadOp, TestTermOp, TestWriteOp, TestSymbolOp, TestAllocatableOp], [TestType, TestRegisterType], [OpAsmDialectInterface()]) module-attribute

TestOp

Bases: IRDLOperation

This operation can produce an arbitrary number of SSAValues with arbitrary types. It is used in filecheck testing to reduce to artificial dependencies on other dialects (i.e. dependencies that only come from the structure of the test rather than the actual dialect).

Source code in xdsl/dialects/test.py 
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
@irdl_op_definition
class TestOp(IRDLOperation):
    """
    This operation can produce an arbitrary number of SSAValues with arbitrary
    types. It is used in filecheck testing to reduce to artificial dependencies
    on other dialects (i.e. dependencies that only come from the structure of
    the test rather than the actual dialect).
    """

    name = "test.op"

    res = var_result_def()
    ops = var_operand_def()
    regs = var_region_def()

    prop1 = opt_prop_def()
    prop2 = opt_prop_def()
    prop3 = opt_prop_def()

    def __init__(
        self,
        operands: Sequence[SSAValue | Operation] = (),
        result_types: Sequence[Attribute] = (),
        attributes: Mapping[str, Attribute | None] | None = None,
        properties: Mapping[str, Attribute | None] | None = None,
        regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
    ):
        super().__init__(
            operands=(operands,),
            result_types=(result_types,),
            attributes=attributes,
            properties=properties,
            regions=(regions,),
        )

name = 'test.op' class-attribute instance-attribute

res = var_result_def() class-attribute instance-attribute

ops = var_operand_def() class-attribute instance-attribute

regs = var_region_def() class-attribute instance-attribute

prop1 = opt_prop_def() class-attribute instance-attribute

prop2 = opt_prop_def() class-attribute instance-attribute

prop3 = opt_prop_def() class-attribute instance-attribute

__init__(operands: Sequence[SSAValue | Operation] = (), result_types: Sequence[Attribute] = (), attributes: Mapping[str, Attribute | None] | None = None, properties: Mapping[str, Attribute | None] | None = None, regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = ())

Source code in xdsl/dialects/test.py 
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def __init__(
    self,
    operands: Sequence[SSAValue | Operation] = (),
    result_types: Sequence[Attribute] = (),
    attributes: Mapping[str, Attribute | None] | None = None,
    properties: Mapping[str, Attribute | None] | None = None,
    regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
):
    super().__init__(
        operands=(operands,),
        result_types=(result_types,),
        attributes=attributes,
        properties=properties,
        regions=(regions,),
    )

TestTermOp

Bases: IRDLOperation

This operation can produce an arbitrary number of SSAValues with arbitrary types. It is used in filecheck testing to reduce to artificial dependencies on other dialects (i.e. dependencies that only come from the structure of the test rather than the actual dialect). Its main difference from TestOp is that it satisfies the IsTerminator trait and can be used as a block terminator operation.

Source code in xdsl/dialects/test.py 
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
@irdl_op_definition
class TestTermOp(IRDLOperation):
    """
    This operation can produce an arbitrary number of SSAValues with arbitrary
    types. It is used in filecheck testing to reduce to artificial dependencies
    on other dialects (i.e. dependencies that only come from the structure of
    the test rather than the actual dialect).
    Its main difference from TestOp is that it satisfies the IsTerminator trait
    and can be used as a block terminator operation.
    """

    name = "test.termop"

    res = var_result_def()
    ops = var_operand_def()
    regs = var_region_def()
    successor = var_successor_def()

    prop1 = opt_prop_def()
    prop2 = opt_prop_def()
    prop3 = opt_prop_def()

    traits = traits_def(IsTerminator())

    def __init__(
        self,
        operands: Sequence[SSAValue | Operation] = (),
        result_types: Sequence[Attribute] = (),
        attributes: Mapping[str, Attribute | None] | None = None,
        properties: Mapping[str, Attribute | None] | None = None,
        successors: Sequence[Block] = (),
        regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
    ):
        super().__init__(
            operands=(operands,),
            result_types=(result_types,),
            attributes=attributes,
            properties=properties,
            successors=(successors,),
            regions=(regions,),
        )

name = 'test.termop' class-attribute instance-attribute

res = var_result_def() class-attribute instance-attribute

ops = var_operand_def() class-attribute instance-attribute

regs = var_region_def() class-attribute instance-attribute

successor = var_successor_def() class-attribute instance-attribute

prop1 = opt_prop_def() class-attribute instance-attribute

prop2 = opt_prop_def() class-attribute instance-attribute

prop3 = opt_prop_def() class-attribute instance-attribute

traits = traits_def(IsTerminator()) class-attribute instance-attribute

__init__(operands: Sequence[SSAValue | Operation] = (), result_types: Sequence[Attribute] = (), attributes: Mapping[str, Attribute | None] | None = None, properties: Mapping[str, Attribute | None] | None = None, successors: Sequence[Block] = (), regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = ())

Source code in xdsl/dialects/test.py 
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
def __init__(
    self,
    operands: Sequence[SSAValue | Operation] = (),
    result_types: Sequence[Attribute] = (),
    attributes: Mapping[str, Attribute | None] | None = None,
    properties: Mapping[str, Attribute | None] | None = None,
    successors: Sequence[Block] = (),
    regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
):
    super().__init__(
        operands=(operands,),
        result_types=(result_types,),
        attributes=attributes,
        properties=properties,
        successors=(successors,),
        regions=(regions,),
    )

TestPureOp

Bases: IRDLOperation

This operation can produce an arbitrary number of SSAValues with arbitrary types. It is used in filecheck testing to reduce to artificial dependencies on other dialects (i.e. dependencies that only come from the structure of the test rather than the actual dialect). Its main difference from TestOp is that it satisfies the Pure trait, so we can test region CSE - this op assumes no side effects nowhere in its regions.

Source code in xdsl/dialects/test.py 
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
@irdl_op_definition
class TestPureOp(IRDLOperation):
    """
    This operation can produce an arbitrary number of SSAValues with arbitrary
    types. It is used in filecheck testing to reduce to artificial dependencies
    on other dialects (i.e. dependencies that only come from the structure of
    the test rather than the actual dialect).
    Its main difference from TestOp is that it satisfies the Pure trait, so we can
    test region CSE - this op assumes no side effects nowhere in its regions.
    """

    name = "test.pureop"

    res = var_result_def()
    ops = var_operand_def()
    regs = var_region_def()
    successor = var_successor_def()

    prop1 = opt_prop_def()
    prop2 = opt_prop_def()
    prop3 = opt_prop_def()

    traits = traits_def(Pure())

    def __init__(
        self,
        operands: Sequence[SSAValue | Operation] = (),
        result_types: Sequence[Attribute] = (),
        attributes: Mapping[str, Attribute | None] | None = None,
        properties: Mapping[str, Attribute | None] | None = None,
        successors: Sequence[Block] = (),
        regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
    ):
        super().__init__(
            operands=(operands,),
            result_types=(result_types,),
            attributes=attributes,
            properties=properties,
            successors=(successors,),
            regions=(regions,),
        )

name = 'test.pureop' class-attribute instance-attribute

res = var_result_def() class-attribute instance-attribute

ops = var_operand_def() class-attribute instance-attribute

regs = var_region_def() class-attribute instance-attribute

successor = var_successor_def() class-attribute instance-attribute

prop1 = opt_prop_def() class-attribute instance-attribute

prop2 = opt_prop_def() class-attribute instance-attribute

prop3 = opt_prop_def() class-attribute instance-attribute

traits = traits_def(Pure()) class-attribute instance-attribute

__init__(operands: Sequence[SSAValue | Operation] = (), result_types: Sequence[Attribute] = (), attributes: Mapping[str, Attribute | None] | None = None, properties: Mapping[str, Attribute | None] | None = None, successors: Sequence[Block] = (), regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = ())

Source code in xdsl/dialects/test.py 
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
def __init__(
    self,
    operands: Sequence[SSAValue | Operation] = (),
    result_types: Sequence[Attribute] = (),
    attributes: Mapping[str, Attribute | None] | None = None,
    properties: Mapping[str, Attribute | None] | None = None,
    successors: Sequence[Block] = (),
    regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
):
    super().__init__(
        operands=(operands,),
        result_types=(result_types,),
        attributes=attributes,
        properties=properties,
        successors=(successors,),
        regions=(regions,),
    )

TestReadOp

Bases: IRDLOperation

This operation can produce an arbitrary number of SSAValues with arbitrary types. It is used in filecheck testing to reduce to artificial dependencies on other dialects (i.e. dependencies that only come from the structure of the test rather than the actual dialect). Its main difference from TestOp is that it satisfies the MemoryReadEffect trait, so we can test CSE - this op assumes it always and only reads.

Source code in xdsl/dialects/test.py 
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
@irdl_op_definition
class TestReadOp(IRDLOperation):
    """
    This operation can produce an arbitrary number of SSAValues with arbitrary
    types. It is used in filecheck testing to reduce to artificial dependencies
    on other dialects (i.e. dependencies that only come from the structure of
    the test rather than the actual dialect).
    Its main difference from TestOp is that it satisfies the MemoryReadEffect trait,
    so we can test CSE - this op assumes it always and only reads.
    """

    name = "test.op_with_memread"

    res = var_result_def()
    ops = var_operand_def()
    regs = var_region_def()
    successor = var_successor_def()

    prop1 = opt_prop_def()
    prop2 = opt_prop_def()
    prop3 = opt_prop_def()

    traits = traits_def(MemoryReadEffect())

    def __init__(
        self,
        operands: Sequence[SSAValue | Operation] = (),
        result_types: Sequence[Attribute] = (),
        attributes: Mapping[str, Attribute | None] | None = None,
        properties: Mapping[str, Attribute | None] | None = None,
        successors: Sequence[Block] = (),
        regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
    ):
        super().__init__(
            operands=(operands,),
            result_types=(result_types,),
            attributes=attributes,
            properties=properties,
            successors=(successors,),
            regions=(regions,),
        )

name = 'test.op_with_memread' class-attribute instance-attribute

res = var_result_def() class-attribute instance-attribute

ops = var_operand_def() class-attribute instance-attribute

regs = var_region_def() class-attribute instance-attribute

successor = var_successor_def() class-attribute instance-attribute

prop1 = opt_prop_def() class-attribute instance-attribute

prop2 = opt_prop_def() class-attribute instance-attribute

prop3 = opt_prop_def() class-attribute instance-attribute

traits = traits_def(MemoryReadEffect()) class-attribute instance-attribute

__init__(operands: Sequence[SSAValue | Operation] = (), result_types: Sequence[Attribute] = (), attributes: Mapping[str, Attribute | None] | None = None, properties: Mapping[str, Attribute | None] | None = None, successors: Sequence[Block] = (), regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = ())

Source code in xdsl/dialects/test.py 
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
def __init__(
    self,
    operands: Sequence[SSAValue | Operation] = (),
    result_types: Sequence[Attribute] = (),
    attributes: Mapping[str, Attribute | None] | None = None,
    properties: Mapping[str, Attribute | None] | None = None,
    successors: Sequence[Block] = (),
    regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
):
    super().__init__(
        operands=(operands,),
        result_types=(result_types,),
        attributes=attributes,
        properties=properties,
        successors=(successors,),
        regions=(regions,),
    )

TestWriteOp

Bases: IRDLOperation

This operation can produce an arbitrary number of SSAValues with arbitrary types. It is used in filecheck testing to reduce to artificial dependencies on other dialects (i.e. dependencies that only come from the structure of the test rather than the actual dialect). Its main difference from TestOp is that it satisfies the MemoryReadEffect trait, so we can test CSE - this op assumes it always and only writes.

Source code in xdsl/dialects/test.py 
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
@irdl_op_definition
class TestWriteOp(IRDLOperation):
    """
    This operation can produce an arbitrary number of SSAValues with arbitrary
    types. It is used in filecheck testing to reduce to artificial dependencies
    on other dialects (i.e. dependencies that only come from the structure of
    the test rather than the actual dialect).
    Its main difference from TestOp is that it satisfies the MemoryReadEffect trait,
    so we can test CSE - this op assumes it always and only writes.
    """

    name = "test.op_with_memwrite"

    res = var_result_def()
    ops = var_operand_def()
    regs = var_region_def()
    successor = var_successor_def()

    prop1 = opt_prop_def()
    prop2 = opt_prop_def()
    prop3 = opt_prop_def()

    traits = traits_def(MemoryWriteEffect())

    def __init__(
        self,
        operands: Sequence[SSAValue | Operation] = (),
        result_types: Sequence[Attribute] = (),
        attributes: Mapping[str, Attribute | None] | None = None,
        properties: Mapping[str, Attribute | None] | None = None,
        successors: Sequence[Block] = (),
        regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
    ):
        super().__init__(
            operands=(operands,),
            result_types=(result_types,),
            attributes=attributes,
            properties=properties,
            successors=(successors,),
            regions=(regions,),
        )

name = 'test.op_with_memwrite' class-attribute instance-attribute

res = var_result_def() class-attribute instance-attribute

ops = var_operand_def() class-attribute instance-attribute

regs = var_region_def() class-attribute instance-attribute

successor = var_successor_def() class-attribute instance-attribute

prop1 = opt_prop_def() class-attribute instance-attribute

prop2 = opt_prop_def() class-attribute instance-attribute

prop3 = opt_prop_def() class-attribute instance-attribute

traits = traits_def(MemoryWriteEffect()) class-attribute instance-attribute

__init__(operands: Sequence[SSAValue | Operation] = (), result_types: Sequence[Attribute] = (), attributes: Mapping[str, Attribute | None] | None = None, properties: Mapping[str, Attribute | None] | None = None, successors: Sequence[Block] = (), regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = ())

Source code in xdsl/dialects/test.py 
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
def __init__(
    self,
    operands: Sequence[SSAValue | Operation] = (),
    result_types: Sequence[Attribute] = (),
    attributes: Mapping[str, Attribute | None] | None = None,
    properties: Mapping[str, Attribute | None] | None = None,
    successors: Sequence[Block] = (),
    regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
):
    super().__init__(
        operands=(operands,),
        result_types=(result_types,),
        attributes=attributes,
        properties=properties,
        successors=(successors,),
        regions=(regions,),
    )

TestConstantOp

Bases: IRDLOperation, HasFolderInterface

Minimal integer constant op for tests that need a ConstantLike producer.

Source code in xdsl/dialects/test.py 
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
@irdl_op_definition
class TestConstantOp(IRDLOperation, HasFolderInterface):
    """
    Minimal integer constant op for tests that need a `ConstantLike` producer.
    """

    name = "test.constant"

    result = result_def(IntegerType)
    value = prop_def(IntegerAttr)

    traits = traits_def(Pure(), ConstantLike())

    def __init__(self, value: int | IntegerAttr, value_type: IntegerType):
        if isinstance(value, int):
            value = IntegerAttr(value, value_type)
        super().__init__(result_types=[value_type], properties={"value": value})

    def fold(self) -> tuple[Attribute]:
        return (self.value,)

name = 'test.constant' class-attribute instance-attribute

result = result_def(IntegerType) class-attribute instance-attribute

value = prop_def(IntegerAttr) class-attribute instance-attribute

traits = traits_def(Pure(), ConstantLike()) class-attribute instance-attribute

__init__(value: int | IntegerAttr, value_type: IntegerType)

Source code in xdsl/dialects/test.py 
271
272
273
274
def __init__(self, value: int | IntegerAttr, value_type: IntegerType):
    if isinstance(value, int):
        value = IntegerAttr(value, value_type)
    super().__init__(result_types=[value_type], properties={"value": value})

fold() -> tuple[Attribute]

Source code in xdsl/dialects/test.py 
276
277
def fold(self) -> tuple[Attribute]:
    return (self.value,)

TestType dataclass

Bases: Data[str], TypeAttribute

This attribute is used for testing in places where any attribute can be used. This allows reducing the artificial dependencies on attributes from other dialects.

Source code in xdsl/dialects/test.py 
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
@irdl_attr_definition
class TestType(Data[str], TypeAttribute):
    """
    This attribute is used for testing in places where any attribute can be
    used. This allows reducing the artificial dependencies on attributes from
    other dialects.
    """

    name = "test.type"

    @classmethod
    def parse_parameter(cls, parser: AttrParser) -> str:
        with parser.in_angle_brackets():
            return parser.parse_str_literal()

    def print_parameter(self, printer: Printer) -> None:
        with printer.in_angle_brackets():
            printer.print_string_literal(self.data)

name = 'test.type' class-attribute instance-attribute

parse_parameter(parser: AttrParser) -> str classmethod

Source code in xdsl/dialects/test.py 
290
291
292
293
@classmethod
def parse_parameter(cls, parser: AttrParser) -> str:
    with parser.in_angle_brackets():
        return parser.parse_str_literal()

print_parameter(printer: Printer) -> None

Source code in xdsl/dialects/test.py 
295
296
297
def print_parameter(self, printer: Printer) -> None:
    with printer.in_angle_brackets():
        printer.print_string_literal(self.data)

TestSymbolOp

Bases: IRDLOperation

This operation can produce an arbitrary number of SSAValues with arbitrary types. It is used in filecheck testing to reduce to artificial dependencies on other dialects (i.e. dependencies that only come from the structure of the test rather than the actual dialect). Its main difference with TestOp is that it satisfies the SymbolOpInterface trait, meaning that we can attach a symbol name to it.

Source code in xdsl/dialects/test.py 
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
@irdl_op_definition
class TestSymbolOp(IRDLOperation):
    """
    This operation can produce an arbitrary number of SSAValues with arbitrary
    types. It is used in filecheck testing to reduce to artificial dependencies
    on other dialects (i.e. dependencies that only come from the structure of
    the test rather than the actual dialect).
    Its main difference with TestOp is that it satisfies the SymbolOpInterface trait,
    meaning that we can attach a symbol name to it.
    """

    name = "test.op_with_symbol"

    res = var_result_def()
    ops = var_operand_def()
    regs = var_region_def()

    sym_name = prop_def(SymbolNameConstraint())
    traits = traits_def(SymbolOpInterface())

    def __init__(
        self,
        operands: Sequence[SSAValue | Operation] = (),
        result_types: Sequence[Attribute] = (),
        attributes: Mapping[str, Attribute | None] | None = None,
        properties: Mapping[str, Attribute | None] | None = None,
        regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
    ):
        super().__init__(
            operands=(operands,),
            result_types=(result_types,),
            attributes=attributes,
            properties=properties,
            regions=(regions,),
        )

name = 'test.op_with_symbol' class-attribute instance-attribute

res = var_result_def() class-attribute instance-attribute

ops = var_operand_def() class-attribute instance-attribute

regs = var_region_def() class-attribute instance-attribute

sym_name = prop_def(SymbolNameConstraint()) class-attribute instance-attribute

traits = traits_def(SymbolOpInterface()) class-attribute instance-attribute

__init__(operands: Sequence[SSAValue | Operation] = (), result_types: Sequence[Attribute] = (), attributes: Mapping[str, Attribute | None] | None = None, properties: Mapping[str, Attribute | None] | None = None, regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = ())

Source code in xdsl/dialects/test.py 
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
def __init__(
    self,
    operands: Sequence[SSAValue | Operation] = (),
    result_types: Sequence[Attribute] = (),
    attributes: Mapping[str, Attribute | None] | None = None,
    properties: Mapping[str, Attribute | None] | None = None,
    regions: Sequence[Region | Sequence[Operation] | Sequence[Block]] = (),
):
    super().__init__(
        operands=(operands,),
        result_types=(result_types,),
        attributes=attributes,
        properties=properties,
        regions=(regions,),
    )

TestAllocatableOp

Bases: IRDLOperation, HasRegisterConstraints

Source code in xdsl/dialects/test.py 
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
@irdl_op_definition
class TestAllocatableOp(IRDLOperation, HasRegisterConstraints):
    name = "test.allocatable"

    in_operands = var_operand_def()
    inout_operands = var_operand_def()
    out_results = var_result_def()
    inout_results = var_result_def()

    traits = traits_def(RegisterAllocatedMemoryEffect())

    irdl_options = (AttrSizedOperandSegments(), AttrSizedResultSegments())

    def __init__(
        self,
        in_operands: Sequence[SSAValue],
        inout_operands: Sequence[SSAValue],
        out_result_types: Sequence[Attribute],
        inout_result_types: Sequence[Attribute],
    ):
        super().__init__(
            operands=(in_operands, inout_operands),
            result_types=(out_result_types, inout_result_types),
        )

    def get_register_constraints(self) -> RegisterConstraints:
        return RegisterConstraints(
            self.in_operands,
            self.out_results,
            tuple(zip(self.inout_operands, self.inout_results)),
        )

name = 'test.allocatable' class-attribute instance-attribute

in_operands = var_operand_def() class-attribute instance-attribute

inout_operands = var_operand_def() class-attribute instance-attribute

out_results = var_result_def() class-attribute instance-attribute

inout_results = var_result_def() class-attribute instance-attribute

traits = traits_def(RegisterAllocatedMemoryEffect()) class-attribute instance-attribute

irdl_options = (AttrSizedOperandSegments(), AttrSizedResultSegments()) class-attribute instance-attribute

__init__(in_operands: Sequence[SSAValue], inout_operands: Sequence[SSAValue], out_result_types: Sequence[Attribute], inout_result_types: Sequence[Attribute])

Source code in xdsl/dialects/test.py 
350
351
352
353
354
355
356
357
358
359
360
def __init__(
    self,
    in_operands: Sequence[SSAValue],
    inout_operands: Sequence[SSAValue],
    out_result_types: Sequence[Attribute],
    inout_result_types: Sequence[Attribute],
):
    super().__init__(
        operands=(in_operands, inout_operands),
        result_types=(out_result_types, inout_result_types),
    )

get_register_constraints() -> RegisterConstraints

Source code in xdsl/dialects/test.py 
362
363
364
365
366
367
def get_register_constraints(self) -> RegisterConstraints:
    return RegisterConstraints(
        self.in_operands,
        self.out_results,
        tuple(zip(self.inout_operands, self.inout_results)),
    )

TestRegisterType dataclass

Bases: RegisterType

Source code in xdsl/dialects/test.py 
370
371
372
373
374
375
376
377
378
379
380
@irdl_attr_definition
class TestRegisterType(RegisterType):
    name = "test.reg"

    @classmethod
    def index_by_name(cls) -> dict[str, int]:
        return {"x0": 0, "x1": 1, "a0": 0, "a1": 1}

    @classmethod
    def infinite_register_prefix(cls):
        return "y"

name = 'test.reg' class-attribute instance-attribute

index_by_name() -> dict[str, int] classmethod

Source code in xdsl/dialects/test.py 
374
375
376
@classmethod
def index_by_name(cls) -> dict[str, int]:
    return {"x0": 0, "x1": 1, "a0": 0, "a1": 1}

infinite_register_prefix() classmethod

Source code in xdsl/dialects/test.py 
378
379
380
@classmethod
def infinite_register_prefix(cls):
    return "y"