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 
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
@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 
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
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 
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 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
@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 
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
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 
111
112
113
114
115
116
117
118
119
120
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
@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 
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
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 
154
155
156
157
158
159
160
161
162
163
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
@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 
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
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 
197
198
199
200
201
202
203
204
205
206
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
@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 
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
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,),
    )

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 
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
@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 
250
251
252
253
@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 
255
256
257
def print_parameter(self, printer: Printer) -> None:
    with printer.in_angle_brackets():
        printer.print_string_literal(self.data)