llvm-project

1
// RUN: mlir-opt %s -split-input-file -verify-diagnostics | FileCheck %s
2

3
func.func @correct_int_types_success() {
4
  "test.int_types"() : () -> (i16, si32, ui64, i8)
5
  "test.int_types"() : () -> (si16, si32, ui64, ui64)
6
  "test.int_types"() : () -> (ui16, si32, ui64, si128)
7
  return
8
}
9

10
// -----
11

12
func.func @wrong_int_type_signedness_failure() {
13
  // expected-error @+1 {{result #1 must be 32-bit signed integer, but got 'ui32'}}
14
  "test.int_types"() : () -> (ui16, ui32, ui64, si8)
15
  return
16
}
17

18
// -----
19

20
func.func @wrong_int_type_signedness_failure() {
21
  // expected-error @+1 {{result #2 must be 64-bit unsigned integer, but got 'si64'}}
22
  "test.int_types"() : () -> (ui16, si32, si64, ui8)
23
  return
24
}
25

26
// -----
27

28
func.func @wrong_int_type_failure() {
29
  // expected-error @+1 {{result #0 must be 16-bit integer, but got 'f16'}}
30
  "test.int_types"() : () -> (f16, si32, ui64, i16)
31
  return
32
}
33

34
// -----
35

36
func.func @wrong_int_type_failure() {
37
  // expected-error @+1 {{result #3 must be integer, but got 'f64'}}
38
  "test.int_types"() : () -> (i16, si32, ui64, f64)
39
  return
40
}
41

42
// -----
43

44
// CHECK-LABEL: @complex_f64_success
45
func.func @complex_f64_success() {
46
  "test.complex_f64"() : () -> (complex<f64>)
47
  return
48
}
49

50
// -----
51

52
// CHECK-LABEL: @complex_f64_tensor_success
53
func.func @complex_f64_tensor_success() {
54
  "test.complex_f64_tensor"() : () -> (tensor<complex<f64>>)
55
  return
56
}
57

58
// -----
59

60
func.func @complex_f64_failure() {
61
  // expected-error@+1 {{op result #0 must be complex type with 64-bit float elements, but got 'f64'}}
62
  "test.complex_f64"() : () -> (f64)
63
  return
64
}
65

66
// -----
67

68
// CHECK-LABEL: @tuple_success
69
func.func @tuple_success() {
70
  "test.tuple_32_bit"() : () -> (tuple<i32>)
71
  return
72
}
73

74
// -----
75

76
// CHECK-LABEL: @tuple_mixed_success
77
func.func @tuple_mixed_success() {
78
  "test.tuple_32_bit"() : () -> (tuple<i32, f32>)
79
  return
80
}
81

82
// -----
83

84
func.func @tuple_empty_success() {
85
  "test.tuple_32_bit"() : () -> (tuple<>)
86
  return
87
}
88

89
// -----
90

91
func.func @tuple_wrong_type_scalar() {
92
  // expected-error@+1 {{must be tuple with any combination of 32-bit signless integer or 32-bit float values}}
93
  "test.tuple_32_bit"() : () -> (tuple<i64>)
94
  return
95
}
96

97
// -----
98

99
func.func @tuple_wrong_type_tensor() {
100
  // expected-error@+1 {{must be tuple with any combination of 32-bit signless integer or 32-bit float values}}
101
  "test.tuple_32_bit"() : () -> (tuple<tensor<i32>>)
102
  return
103
}
104

105
// -----
106

107
// CHECK-LABEL: @nested_tuple_empty_success
108
func.func @nested_tuple_empty_success() {
109
  "test.nested_tuple_32_bit"() : () -> (tuple<>)
110
  return
111
}
112

113
// -----
114

115
// CHECK-LABEL: @nested_tuple_one_level_success
116
func.func @nested_tuple_one_level_success() {
117
  "test.nested_tuple_32_bit"() : () -> (tuple<i32>)
118
  return
119
}
120

121
// -----
122

123
// CHECK-LABEL: @nested_tuple_multi_level_success
124
func.func @nested_tuple_multi_level_success() {
125
  "test.nested_tuple_32_bit"() : () -> (tuple<i32, tuple<i32, tuple<i32>>>)
126
  return
127
}
128

129
// -----
130

131
// CHECK-LABEL: @nested_tuple_multi_level_mixed_success
132
func.func @nested_tuple_multi_level_mixed_success() {
133
  "test.nested_tuple_32_bit"() : () -> (tuple<i32, tuple<f32, tuple<i32>>>)
134
  return
135
}
136

137
// -----
138

139
func.func @nested_tuple_multi_level_wrong_type() {
140
  // expected-error@+1 {{must be nested tuple with any combination of 32-bit signless integer or 32-bit float values}}
141
  "test.nested_tuple_32_bit"() : () -> (tuple<i32, tuple<i32, tuple<i64>>>)
142
  return
143
}
144

145
// -----
146

147
// CHECK-LABEL: func @rank_less_than_2_I8_F32_memref_success
148
func.func @rank_less_than_2_I8_F32_memref_success() {
149
  "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<i8>)
150
  "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<3xi8>)
151
  "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<f32>)
152
  "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<1xf32>)
153
  return
154
}
155

156
// -----
157

158
func.func @rank_less_than_2_I8_F32_memref_bad_type() {
159
  // expected-error@+1 {{must be 0D/1D memref of 8-bit signless integer or 32-bit float values}}
160
  "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<i16>)
161
  return
162
}
163

164
// -----
165

166
func.func @rank_less_than_2_I8_F32_memref_bad_rank() {
167
  // expected-error@+1 {{must be 0D/1D memref of 8-bit signless integer or 32-bit float values}}
168
  "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<1x2xi8>)
169
  return
170
}
171

172
// -----
173

174
func.func @nd_tensor_of_success(%arg0: tensor<f32>, %arg1: tensor<10xf32>, %arg2: tensor<20x30xi16>, %arg3: tensor<40x50x60xi16>, %arg4: tensor<70x80x90x100xi16>) {
175
  "test.nd_tensor_of"(%arg0, %arg1, %arg2, %arg3, %arg4) : (tensor<f32>, tensor<10xf32>, tensor<20x30xi16>, tensor<40x50x60xi16>, tensor<70x80x90x100xi16>) -> ()
176
  return
177
}
178

179
// -----
180

181
func.func @nd_tensor_of_success_wrong_type_0d(%arg0: tensor<f32>, %arg1: tensor<10xf32>, %arg2: tensor<20x30xi16>, %arg3: tensor<40x50x60xi16>, %arg4: tensor<70x80x90x100xi32>) {
182
  // expected-error @+1 {{'test.nd_tensor_of' op operand #0 must be 0D tensor of 32-bit float values}}
183
  "test.nd_tensor_of"(%arg1, %arg1, %arg2, %arg3, %arg4) : (tensor<10xf32>, tensor<10xf32>, tensor<20x30xi16>, tensor<40x50x60xi16>, tensor<70x80x90x100xi32>) -> ()
184
  return
185
}
186

187
// -----
188

189
func.func @nd_tensor_of_success_wrong_type_4d(%arg0: tensor<f32>, %arg1: tensor<10xf32>, %arg2: tensor<20x30xi16>, %arg3: tensor<40x50x60xi16>, %arg4: tensor<70x80x90x100xi32>) {
190
  // expected-error @+1 {{'test.nd_tensor_of' op operand #4 must be 4D tensor of 16-bit signless integer values}}
191
  "test.nd_tensor_of"(%arg0, %arg1, %arg2, %arg3, %arg3) : (tensor<f32>, tensor<10xf32>, tensor<20x30xi16>, tensor<40x50x60xi16>, tensor<40x50x60xi16>) -> ()
192
  return
193
}
194

195
// -----
196

197
func.func @ranked_tensor_success(%arg0: tensor<i8>, %arg1: tensor<1xi32>, %arg2: tensor<?x?xf32>) {
198
  "test.ranked_tensor_op"(%arg0) : (tensor<i8>) -> ()
199
  "test.ranked_tensor_op"(%arg1) : (tensor<1xi32>) -> ()
200
  "test.ranked_tensor_op"(%arg2) : (tensor<?x?xf32>) -> ()
201
  return
202
}
203

204
// -----
205

206
func.func @ranked_tensor_success(%arg0: tensor<*xf32>) {
207
  // expected-error @+1 {{must be ranked tensor of any type values}}
208
  "test.ranked_tensor_op"(%arg0) : (tensor<*xf32>) -> ()
209
  return
210
}
211

212
// -----
213

214
func.func @ranked_tensor_success(%arg0: vector<2xf32>) {
215
  // expected-error @+1 {{must be ranked tensor of any type values}}
216
  "test.ranked_tensor_op"(%arg0) : (vector<2xf32>) -> ()
217
  return
218
}
219

220
// -----
221

222
func.func @multi_tensor_rank_of_success(%arg0: tensor<i8>, %arg1: tensor<i32>, %arg2: tensor<f32>, %arg3: tensor<1xi8>, %arg4: tensor<1xi32>, %arg5: tensor<1xf32>) {
223
  "test.multi_tensor_rank_of"(%arg0) : (tensor<i8>) -> ()
224
  "test.multi_tensor_rank_of"(%arg1) : (tensor<i32>) -> ()
225
  "test.multi_tensor_rank_of"(%arg2) : (tensor<f32>) -> ()
226
  "test.multi_tensor_rank_of"(%arg3) : (tensor<1xi8>) -> ()
227
  "test.multi_tensor_rank_of"(%arg4) : (tensor<1xi32>) -> ()
228
  "test.multi_tensor_rank_of"(%arg5) : (tensor<1xf32>) -> ()
229
  return
230
}
231

232
// -----
233

234
func.func @multi_tensor_rank_of_wrong_unranked_type(%arg0: tensor<2x2xi8>) {
235
  // expected-error @+1 {{'test.multi_tensor_rank_of' op operand #0 must be 0D/1D tensor of 8-bit signless integer or 32-bit signless integer or 32-bit float values}}
236
  "test.multi_tensor_rank_of"(%arg0) : (tensor<2x2xi8>) -> ()
237
  return
238
}
239

240
// -----
241

242
func.func @multi_tensor_rank_of_wrong_element_type(%arg0: tensor<2xi16>) {
243
  // expected-error @+1 {{'test.multi_tensor_rank_of' op operand #0 must be 0D/1D tensor of 8-bit signless integer or 32-bit signless integer or 32-bit float values}}
244
  "test.multi_tensor_rank_of"(%arg0) : (tensor<2xi16>) -> ()
245
  return
246
}
247

248
// -----
249

250
// CHECK-LABEL: @fixed_element_types
251
func.func @fixed_element_types(%ti32: tensor<* x i32>, %tf32: tensor<* x f32>, %mi32 : memref<2x3xi32>, %vf32 : vector<2xf32>) {
252
  "test.arg_and_res_have_fixed_element_types"(%ti32, %tf32) : (tensor<* x i32>, tensor<* x f32>) -> tensor<* x i16>
253
  "test.arg_and_res_have_fixed_element_types"(%mi32, %vf32) : (memref<2x3xi32>, vector<2xf32>) -> memref<1x2xi16>
254
  return
255
}
256

257
// -----
258

259
func.func @fixed_element_types(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
260
  // expected-error@+1 {{'res' is 16-bit signless integer}}
261
  "test.arg_and_res_have_fixed_element_types"(%arg0, %arg1) : (tensor<* x i32>, tensor<* x f32>) -> tensor<* x i32>
262
  return
263
}
264

265
// -----
266

267
func.func @fixed_element_types(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
268
  // expected-error@+1 {{fixed type combination}}
269
  "test.arg_and_res_have_fixed_element_types"(%arg1, %arg0) : (tensor<* x f32>, tensor<* x i32>) -> tensor<* x i16>
270
  return
271
}
272

273
// -----
274

275
// CHECK-LABEL: same_element_types_success
276
func.func @same_element_types_success(%ti32: tensor<* x i32>, %i32 : i32, %mi32 : memref<2x3xi32>) {
277
  "test.operands_have_same_element_type"(%ti32, %ti32): (tensor<* x i32>, tensor<* x i32>) -> ()
278
  "test.operands_have_same_element_type"(%i32, %ti32): (i32, tensor<* x i32>) -> ()
279
  "test.operands_have_same_element_type"(%i32, %mi32): (i32, memref<2x3xi32>) -> ()
280
  return
281
}
282

283

284
// -----
285

286
func.func @same_element_types_failure(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
287
  // expected-error@+1 {{verify that all of {x, y} have same element type}}
288
  "test.operands_have_same_element_type"(%arg1, %arg0): (tensor<* x f32>, tensor<* x i32>) -> ()
289
  return
290
}
291

292
// -----
293

294
// CHECK-LABEL: same_element_types_success
295
func.func @same_element_types_success(%ti32: tensor<* x i32>, %tf32: tensor<* x f32>) {
296
  "test.operand0_and_result_have_same_element_type"(%tf32, %ti32) : (tensor<* x f32>, tensor<* x i32>) -> tensor<* x f32>
297
  "test.operand0_and_result_have_same_element_type"(%tf32, %ti32) : (tensor<* x f32>, tensor<* x i32>) -> memref<2x3xf32>
298
  "test.operand0_and_result_have_same_element_type"(%tf32, %ti32) : (tensor<* x f32>, tensor<* x i32>) -> f32
299
  return
300
}
301

302
// -----
303

304
func.func @same_element_types_failure(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
305
  // expected-error@+1 {{all of {x, res} have same element type}}
306
  "test.operand0_and_result_have_same_element_type"(%arg1, %arg0) : (tensor<* x f32>, tensor<* x i32>) -> tensor<* x i32>
307
  return
308
}
309

310
// -----
311

312
// CHECK-LABEL: same_types
313
func.func @same_types(%ti32: tensor<* x i32>, %tf32: tensor<* x f32>) {
314
  "test.operands_have_same_type"(%ti32, %ti32) : (tensor<* x i32>, tensor<* x i32>) -> ()
315
  "test.operand0_and_result_have_same_type"(%ti32, %tf32) : (tensor<* x i32>, tensor<* x f32>) -> tensor<* x i32>
316
  return
317
}
318

319
// -----
320

321
func.func @same_types_failure(%ti32: tensor<* x i32>, %i32: i32) {
322
  // expected-error@+1 {{all of {x, y} have same type}}
323
  "test.operands_have_same_type"(%ti32, %i32) : (tensor<* x i32>, i32) -> ()
324
  return
325
}
326

327
// -----
328

329
func.func @same_types_element_mismatch(%ti32: tensor<* x i32>, %tf32: tensor<* x f32>) {
330
  // expected-error@+1 {{all of {x, y} have same type}}
331
  "test.operands_have_same_type"(%ti32, %tf32) : (tensor<* x i32>, tensor<* x f32>) -> ()
332
  return
333
}
334

335
// -----
336

337
func.func @same_types_shape_mismatch(%arg0: tensor<1x2xi32>, %arg1: tensor<2x1xi32>) {
338
  // expected-error@+1 {{all of {x, y} have same type}}
339
  "test.operands_have_same_type"(%arg0, %arg1) : (tensor<1x2xi32>, tensor<2x1xi32>) -> ()
340
  return
341
}
342

343
// -----
344

345
// CHECK-LABEL: same_rank_success
346
func.func @same_rank_success(%t1xi : tensor<1xi32>, %t2xf : tensor<2xf32>, %m3xi : memref<3xi32>, %t1x2xf : tensor<1x2xf32>, %t1x2xi : tensor<1x2xi32>) {
347
  "test.operands_have_same_rank"(%t1xi, %t2xf) : (tensor<1xi32>, tensor<2xf32>) -> ()
348
  "test.operands_have_same_rank"(%t1xi, %m3xi) : (tensor<1xi32>, memref<3xi32>) -> ()
349
  "test.operand0_and_result_have_same_rank"(%t1xi, %t1x2xf) : (tensor<1xi32>, tensor<1x2xf32>) -> (tensor<3xf32>)
350
  "test.operand0_and_result_have_same_rank"(%t1x2xi, %t1x2xf) : (tensor<1x2xi32>, tensor<1x2xf32>) -> (tensor<3x3xf64>)
351
  return
352
}
353

354
// -----
355

356
func.func @same_rank_failure(%arg0: tensor<1xi32>, %arg1: tensor<1x2xf32>) {
357
  // expected-error@+1 {{all of {x, y} have same rank}}
358
  "test.operands_have_same_rank"(%arg0, %arg1) : (tensor<1xi32>, tensor<1x2xf32>) -> ()
359
  return
360
}
361

362
// -----
363

364
func.func @same_rank_failure(%arg0: tensor<1xi32>, %arg1: tensor<1x2xf32>) {
365
  // expected-error@+1 {{all of {x, res} have same rank}}
366
  "test.operand0_and_result_have_same_rank"(%arg0, %arg1) : (tensor<1xi32>, tensor<1x2xf32>) -> (tensor<i32>)
367
  return
368
}
369

370
// -----
371

372
func.func @same_rank_failure(%arg0: tensor<1x2xi32>, %arg1: tensor<1x2xf32>) {
373
  // expected-error@+1 {{all of {x, res} have same rank}}
374
  "test.operand0_and_result_have_same_rank"(%arg0, %arg1) : (tensor<1x2xi32>, tensor<1x2xf32>) -> (tensor<3xi32>)
375
  return
376
}
377

378
// -----
379

380
// CHECK-LABEL: same_rank_if_known_success
381
func.func @same_rank_if_known_success(%t1xi : tensor<1xi32>, %t2xf : tensor<2xf32>, %m3xi : memref<3xi32>, %t1x2xf : tensor<1x2xf32>, %tuxi : tensor<*xi32>) {
382
  %0 = "test.operands_and_result_have_same_rank"(%t1xi, %t2xf) : (tensor<1xi32>, tensor<2xf32>) -> (tensor<3xf64>)
383
  %1 = "test.operands_and_result_have_same_rank"(%t1xi, %m3xi) : (tensor<1xi32>, memref<3xi32>) -> (tensor<3xi64>)
384
  %3 = "test.operands_and_result_have_same_rank"(%tuxi, %t2xf) : (tensor<*xi32>, tensor<2xf32>) -> (tensor<2xf32>)
385
  %4 = "test.operands_and_result_have_same_rank"(%t1x2xf, %tuxi) : (tensor<1x2xf32>, tensor<*xi32>) -> (tensor<1x2xf64>)
386
  return
387
}
388

389
// -----
390

391
func.func @same_rank_if_known_failure(%arg0: tensor<1xi32>, %arg1: tensor<1x2xf32>) {
392
  // expected-error@+1 {{operands don't have matching ranks}}
393
  %0 = "test.operands_and_result_have_same_rank"(%arg0, %arg1) : (tensor<1xi32>, tensor<1x2xf32>) -> (tensor<*xf32>)
394
  return
395
}
396

397
// -----
398

399
func.func @same_rank_if_known_failure(%arg0: tensor<1xi32>, %arg1: tensor<1x2xf32>) {
400
  // expected-error@+1 {{result type has different rank than operands}}
401
  %0 = "test.operands_and_result_have_same_rank"(%arg1, %arg1) : (tensor<1x2xf32>, tensor<1x2xf32>) -> (tensor<1x2x3xf32>)
402
  return
403
}
404

405
// -----
406

407
// CHECK-LABEL: same_shape_success
408
func.func @same_shape_success(%t2x3: tensor<2x3xi32>, %m2x3: memref<2x3xf32>, %v2x3 : vector<2x3xi32>, %t4x5 : tensor<4x5xi32>) {
409
  "test.operand0_and_result_have_same_shape"(%t2x3, %t4x5) : (tensor<2x3xi32>, tensor<4x5xi32>) -> (tensor<2x3xf32>)
410
  "test.operand0_and_result_have_same_shape"(%t2x3, %t4x5) : (tensor<2x3xi32>, tensor<4x5xi32>) -> (memref<2x3xf32>)
411
  "test.operand0_and_result_have_same_shape"(%t2x3, %t4x5) : (tensor<2x3xi32>, tensor<4x5xi32>) -> (vector<2x3xf32>)
412
  return
413
}
414

415
// -----
416

417
func.func @same_shape_failure(%t2x3: tensor<2x3xi32>, %t4x5 : tensor<4x5xi32>) {
418
  // expected-error@+1 {{all of {x, res} have same shape}}
419
  "test.operand0_and_result_have_same_shape"(%t2x3, %t4x5) : (tensor<2x3xi32>, tensor<4x5xi32>) -> (tensor<1x3xf32>)
420
  return
421
}
422

423
// -----
424

425
// CHECK-LABEL: same_element_count_success
426
func.func @same_element_count_success(%arg0: tensor<36xi32>, %arg1: tensor<1x2xf32>, %arg3: tensor<f32>) {
427
  "test.operand0_and_result_have_same_element_count"(%arg0, %arg1) : (tensor<36xi32>, tensor<1x2xf32>) -> (tensor<3x4x3xf32>)
428
  "test.operand0_and_result_have_same_element_count"(%arg0, %arg1) : (tensor<36xi32>, tensor<1x2xf32>) -> (tensor<3x12xf64>)
429
  "test.operand0_and_result_have_same_element_count"(%arg3, %arg1) : (tensor<f32>, tensor<1x2xf32>) -> (memref<1x1x1xi32>)
430
  return
431
}
432

433
// -----
434

435
func.func @same_element_count_failure(%arg0: tensor<1xi32>, %arg1: tensor<1x2xf32>) {
436
  // expected-error@+1 {{all of {x, res} have same element count}}
437
  "test.operand0_and_result_have_same_element_count"(%arg0, %arg1) : (tensor<1xi32>, tensor<1x2xf32>) -> (tensor<2xi32>)
438
  return
439
}
440

441
// -----
442

443
func.func @four_equals_five() {
444
  // expected-error@+1 {{failed to verify that 4 equals 5}}
445
  "test.four_equals_five"() : () -> ()
446
  return
447
}
448

449
// -----
450

451
func.func @operand_rank_equals_result_size_success(%arg : tensor<1x2x3x4xi32>) {
452
  "test.operand_rank_equals_result_size"(%arg) : (tensor<1x2x3x4xi32>) -> tensor<4xi32>
453
  "test.operand_rank_equals_result_size"(%arg) : (tensor<1x2x3x4xi32>) -> memref<2x2xf32>
454
  return
455
}
456

457
// -----
458

459
func.func @operand_rank_equals_result_size_failure(%arg : tensor<1x2x3x4xi32>) {
460
  // expected-error@+1 {{failed to verify that operand rank equals result size}}
461
  "test.operand_rank_equals_result_size"(%arg) : (tensor<1x2x3x4xi32>) -> tensor<2xi32>
462
  return
463
}
464

465
// -----
466

467
func.func @same_types_element_mismatch(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
468
  // expected-error@+1 {{op failed to verify that all of {x, res} have same type}}
469
  "test.operand0_and_result_have_same_type"(%arg0, %arg1) : (tensor<* x i32>, tensor<* x f32>) -> tensor<* x f32>
470
  return
471
}
472

473
// -----
474

475
func.func @same_types_shape_mismatch(%arg0: tensor<1x2xi32>, %arg1: tensor<2x1xi32>) {
476
  // expected-error@+1 {{op failed to verify that all of {x, res} have same type}}
477
  "test.operand0_and_result_have_same_type"(%arg0, %arg1) : (tensor<1x2xi32>, tensor<2x1xi32>) -> tensor<2x1xi32>
478
  return
479
}
480

481
// -----
482

483
func.func @does_not_have_i32(%arg0: tensor<1x2xi32>, %arg1: none) {
484
  // expected-error@+1 {{either both none type operands or first is not none}}
485
  "test.if_first_operand_is_none_then_so_is_second"(%arg1, %arg0) : (none, tensor<1x2xi32>) -> ()
486
  return
487
}
488

489
// -----
490

491
func.func @does_not_have_static_memref(%arg0: memref<?xi32>) {
492
  // expected-error@+1 {{'test.takes_static_memref' op operand #0 must be statically shaped memref of any type values}}
493
  "test.takes_static_memref"(%arg0) : (memref<?xi32>) -> ()
494
}
495

496
// -----
497

498
func.func @elements_attr_not_i32_f32() {
499
  // expected-error@+1 {{32-bit signless integer elements attribute}}
500
  "test.i32ElementsAttr"() {attr = dense<[1.0, 20.0]>:tensor<2xf32>} : () -> ()
501
  return
502
}
503

504
// -----
505

506
func.func @elements_attr_not_i32_i64() {
507
  // expected-error@+1 {{32-bit signless integer elements attribute}}
508
  "test.i32ElementsAttr"() {attr = dense<[1, 20]>:tensor<2xi64>} : () -> ()
509
  return
510
}
511

512

513
// -----
514

515
func.func @elements_attr_i32(%arg0: tensor<1x2xi32>) {
516
  "test.i32ElementsAttr"() {attr = dense<[1, 2]>:tensor<2xi32>} : () -> ()
517
  return
518
}
519

520
// -----
521

522
func.func @elements_attr_index() {
523
  "test.indexElementsAttr"() {attr = dense<[1, 2]>:tensor<2xindex>} : () -> ()
524
  return
525
}
526

527
// -----
528

529
func.func @elements_attr_not_index() {
530
  // expected-error@+1 {{index elements attribute}}
531
  "test.indexElementsAttr"() {attr = dense<[1, 2]>:tensor<2xi32>} : () -> ()
532
  return
533
}
534

535
// -----
536

537
// CHECK-LABEL: @struct_success
538
func.func @struct_success() {
539
  "test.simple_struct"() : () -> (!test.struct<{a, i32}, {b, f64}>)
540
  return
541
}
542

543
// -----
544

545
// CHECK-LABEL: @struct_with_field_names_like_types
546
func.func @struct_with_field_names_like_types() {
547
  "test.struct_with_field_names_like_types"() : () -> (!test.struct<{i32, i32}, {f64, f64}>)
548
  return
549
}
550

551
// -----
552

553
func.func @struct_bad_keywords() {
554
  // expected-error@+1 {{expected valid keyword}}
555
  "test.struct_bad_keywords"() : () -> (!test.struct<{42, i32}>)
556
  return
557
}
558