Skip to content

Test

test

Test = Dialect('test', [TestOp, TestPureOp, TestReadOp, TestTermOp, TestWriteOp], [TestType], [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 
42
43
44
45
46
47
48
49
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
@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 
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
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 
 78
 79
 80
 81
 82
 83
 84
 85
 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
@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 
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
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 
121
122
123
124
125
126
127
128
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
@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 
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
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 
164
165
166
167
168
169
170
171
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
@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 
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
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 
207
208
209
210
211
212
213
214
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
@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 
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
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 
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
@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 
263
264
265
266
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 
268
269
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 
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
@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 
282
283
284
285
@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 
287
288
289
def print_parameter(self, printer: Printer) -> None:
    with printer.in_angle_brackets():
        printer.print_string_literal(self.data)