| // RUN: not mlir-pdll %s -I %S -I %S/../../../include -split-input-file 2>&1 | FileCheck %s |
| |
| //===----------------------------------------------------------------------===// |
| // Reference Expr |
| //===----------------------------------------------------------------------===// |
| |
| Pattern { |
| // CHECK: expected identifier constraint |
| let foo = Foo: ; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: undefined reference to `bar` |
| let foo = bar; |
| } |
| |
| // ----- |
| |
| Pattern FooPattern { |
| erase _: Op; |
| } |
| |
| Pattern { |
| // CHECK: invalid reference to `FooPattern` |
| let foo = FooPattern; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `:` after `_` variable |
| let foo = _; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected identifier constraint |
| let foo = _: ; |
| } |
| |
| // ----- |
| |
| //===----------------------------------------------------------------------===// |
| // Call Expr |
| //===----------------------------------------------------------------------===// |
| |
| Constraint foo(value: Value); |
| |
| Pattern { |
| // CHECK: expected `)` after argument list |
| foo(_: Value{}; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected a reference to a callable `Constraint` or `Rewrite`, but got: `Op` |
| let foo: Op; |
| foo(); |
| } |
| |
| // ----- |
| |
| Constraint Foo(); |
| |
| Pattern { |
| // CHECK: invalid number of arguments for constraint call; expected 0, but got 1 |
| Foo(_: Value); |
| } |
| |
| // ----- |
| |
| Constraint Foo(arg: Value); |
| |
| Pattern { |
| // CHECK: unable to convert expression of type `Attr` to the expected type of `Value` |
| Foo(attr<"i32">); |
| } |
| |
| // ----- |
| |
| //===----------------------------------------------------------------------===// |
| // Member Access Expr |
| //===----------------------------------------------------------------------===// |
| |
| Pattern { |
| // CHECK: expected identifier or numeric member name |
| let root: Op; |
| erase root.<>; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: invalid member access `unknown_result` on expression of type `Op` |
| let root: Op; |
| erase root.unknown_result; |
| } |
| |
| // ----- |
| |
| Pattern { |
| let tuple = (result1 = value: Value, result2 = value); |
| |
| // CHECK: invalid member access `unknown_result` on expression of type `Tuple<result1: Value, result2: Value>` |
| let tuple2 = (tuple.result1, tuple.unknown_result); |
| |
| erase op<>; |
| } |
| |
| // ----- |
| |
| Pattern { |
| let tuple = (result1 = value: Value, result2 = value); |
| |
| // CHECK: invalid member access `2` on expression of type `Tuple<result1: Value, result2: Value>` |
| let tuple2 = (tuple.0, tuple.2); |
| |
| erase op<>; |
| } |
| |
| // ----- |
| |
| //===----------------------------------------------------------------------===// |
| // Range Expr |
| //===----------------------------------------------------------------------===// |
| |
| Pattern { |
| // CHECK: unable to convert expression of type `Tuple<>` to the expected type of `ValueRange` |
| // CHECK: Tuple to Range conversion is currently only allowed within a rewrite context |
| erase op<>(()); |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: unable to convert expression of type `Tuple<Value, Type>` to the expected type of `ValueRange` |
| replace op<>(arg: Value) -> (type: Type) with op<test.op>((arg, type)); |
| } |
| |
| // ----- |
| |
| //===----------------------------------------------------------------------===// |
| // Tuple Expr |
| //===----------------------------------------------------------------------===// |
| |
| Pattern { |
| // CHECK: expected `)` after tuple element list |
| let tuple = (value: Value, value; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: unable to build a tuple with `Tuple<Value, Value>` element |
| let tuple = (_: Value, _: Value); |
| let var = (tuple); |
| erase op<>; |
| } |
| |
| // ----- |
| |
| Constraint Foo(); |
| |
| Pattern { |
| // CHECK: unable to build a tuple with `Constraint` element |
| let tuple = (Foo); |
| erase op<>; |
| } |
| |
| // ----- |
| |
| Constraint Foo(op: Op) {} |
| |
| Pattern { |
| // CHECK: unable to negate non native constraints |
| let root = op<>; |
| not Foo(root); |
| } |
| |
| // ----- |
| |
| Rewrite Foo(); |
| |
| Pattern { |
| // CHECK: unable to build a tuple with `Rewrite` element |
| let tuple = (Foo); |
| erase op<>; |
| } |
| |
| // ----- |
| |
| Rewrite Foo(op: Op); |
| |
| Pattern { |
| // CHECK: unable to negate a Rewrite |
| let root = op<>; |
| rewrite root with { |
| not Foo(root); |
| } |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected native constraint |
| not attr<"0 : i1"> |
| erase _; |
| } |
| |
| // ----- |
| |
| Pattern { |
| let tuple = (attr<"3 : i34">); |
| // CHECK: expected `(` after function name |
| not tuple.0; |
| erase _; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected expression |
| let tuple = (10 = _: Value); |
| erase op<>; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: duplicate tuple element label `field` |
| // CHECK: see previous label use here |
| let tuple = (field = _: Value, field = _: Value); |
| erase op<>; |
| } |
| |
| // ----- |
| |
| //===----------------------------------------------------------------------===// |
| // `attr` Expr |
| //===----------------------------------------------------------------------===// |
| |
| Pattern { |
| // CHECK: expected string literal containing MLIR attribute |
| let foo = attr<foo>; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `>` after attribute literal |
| let foo = attr<""<>; |
| } |
| |
| // ----- |
| |
| //===----------------------------------------------------------------------===// |
| // `op` Expr |
| //===----------------------------------------------------------------------===// |
| |
| Pattern { |
| // CHECK: expected `)` after operation operand list |
| let value: Value; |
| let foo = op<func.func>(value<; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: unable to convert expression of type `Attr` to the expected type of `ValueRange` |
| let attr: Attr; |
| let foo = op<func.func>(attr); |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `Value` or `ValueRange` convertible expression, but got `Type` |
| let foo = op<>(_: Type, _: TypeRange); |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected identifier or string attribute name |
| let foo = op<> { 10; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `Attr` expression, but got `Value` |
| let foo = op<> { foo = _: Value }; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `}` after operation attribute list |
| let foo = op<> { "foo" {; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `(` before operation result type list |
| let foo = op<> -> ); |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: unable to convert expression of type `ValueRange` to the expected type of `TypeRange` |
| let foo = op<> -> (_: ValueRange); |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `Type` or `TypeRange` convertible expression, but got `Value` |
| let foo = op<> -> (_: Value, _: ValueRange); |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `)` after operation result type list |
| let value: TypeRange; |
| let foo = op<> -> (value<; |
| } |
| |
| // ----- |
| |
| #include "include/ops.td" |
| |
| Pattern { |
| // CHECK: invalid number of operand groups for `test.all_empty`; expected 0, but got 2 |
| // CHECK: see the definition of `test.all_empty` here |
| let foo = op<test.all_empty>(operand1: Value, operand2: Value); |
| } |
| |
| // ----- |
| |
| #include "include/ops.td" |
| |
| Pattern { |
| // CHECK: invalid number of result groups for `test.all_empty`; expected 0, but got 2 |
| // CHECK: see the definition of `test.all_empty` here |
| let foo = op<test.all_empty> -> (result1: Type, result2: Type); |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: warning: operation result types are marked to be inferred, but |
| // CHECK-SAME: `test.unknown_inferred_result_op` is unknown. |
| // CHECK-SAME: Ensure that `test.unknown_inferred_result_op` supports zero |
| // CHECK-SAME: results or implements `InferTypeOpInterface`. |
| // CHECK-SAME: Include the ODS definition of this operation to remove this |
| // CHECK-SAME: warning. |
| rewrite _: Op with { |
| op<test.unknown_inferred_result_op>; |
| }; |
| } |
| |
| // ----- |
| |
| #include "include/ops.td" |
| |
| Pattern { |
| // CHECK: warning: operation result types are marked to be inferred, but |
| // CHECK-SAME: `test.multiple_single_result` does not provide an implementation |
| // CHECK-SAME: of `InferTypeOpInterface`. Ensure that `test.multiple_single_result` |
| // CHECK-SAME: attaches `InferTypeOpInterface` at runtime, or add support |
| // CHECK-SAME: to the ODS definition to remove this warning. |
| // CHECK: see the definition of `test.multiple_single_result` here |
| rewrite _: Op with { |
| op<test.multiple_single_result>; |
| }; |
| } |
| |
| // ----- |
| |
| //===----------------------------------------------------------------------===// |
| // `type` Expr |
| //===----------------------------------------------------------------------===// |
| |
| Pattern { |
| // CHECK: expected string literal containing MLIR type |
| let foo = type<foo; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `>` after type literal |
| let foo = type<""; |
| } |