| // RUN: not mlir-pdll %s -I %S -I %S/../../../include -split-input-file 2>&1 | FileCheck %s |
| |
| // CHECK: expected top-level declaration, such as a `Pattern` |
| 10 |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `;` after statement |
| erase _: Op |
| } |
| |
| // ----- |
| |
| //===----------------------------------------------------------------------===// |
| // `erase` |
| //===----------------------------------------------------------------------===// |
| |
| Pattern { |
| // CHECK: expected expression |
| erase; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `Op` expression |
| erase _: Attr; |
| } |
| |
| // ----- |
| |
| //===----------------------------------------------------------------------===// |
| // `let` |
| //===----------------------------------------------------------------------===// |
| |
| Pattern { |
| // CHECK: expected identifier after `let` to name a new variable |
| let 5; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: `_` may only be used to define "inline" variables |
| let _; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected expression |
| let foo: Attr<>; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected expression of `Type` in type constraint |
| let foo: Attr<_: Attr>; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `>` after variable type constraint |
| let foo: Attr<_: Type{}; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: the type of this variable has already been constrained |
| let foo: [Attr<_: Type>, Attr<_: Type]; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `.` after dialect namespace |
| let foo: Op<builtin>; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected operation name after dialect namespace |
| let foo: Op<builtin.>; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `>` after operation name |
| let foo: Op<func.func<; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected expression |
| let foo: Value<>; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected expression of `Type` in type constraint |
| let foo: Value<_: Attr>; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `>` after variable type constraint |
| let foo: Value<_: Type{}; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: the type of this variable has already been constrained |
| let foo: [Value<_: Type>, Value<_: Type]; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected expression |
| let foo: ValueRange<10>; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected expression of `TypeRange` in type constraint |
| let foo: ValueRange<_: Type>; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `>` after variable type constraint |
| let foo: ValueRange<_: Type{}; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: the type of this variable has already been constrained |
| let foo: [ValueRange<_: Type>, ValueRange<_: Type]; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: unknown reference to constraint `UnknownConstraint` |
| let foo: UnknownConstraint; |
| } |
| |
| // ----- |
| |
| Pattern Foo { |
| erase root: Op; |
| } |
| |
| Pattern { |
| // CHECK: invalid reference to non-constraint |
| let foo: Foo; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: constraint type `Attr` is incompatible with the previously inferred type `Value` |
| let foo: [Value, Attr]; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `]` after constraint list |
| let foo: [Attr[]; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected expression |
| let foo: Attr = ; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: type constraints are not permitted on variables with initializers |
| let foo: ValueRange<_: Type> = _: Op; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: unable to infer type for variable `foo` |
| // CHECK: note: the type of a variable must be inferable from the constraint list or the initializer |
| let foo; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: unable to convert expression of type `Attr` to the expected type of `Value` |
| let foo: Value = _: Attr; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: :7:7: error: `foo` has already been defined |
| // CHECK: :6:7: note: see previous definition here |
| let foo: Attr; |
| let foo: Attr; |
| } |
| |
| // ----- |
| |
| Constraint Foo(); |
| |
| Pattern { |
| // CHECK: unable to define variable of `Constraint` type |
| let foo = Foo; |
| } |
| |
| // ----- |
| |
| Rewrite Foo(); |
| |
| Pattern { |
| // CHECK: unable to define variable of `Rewrite` type |
| let foo = Foo; |
| } |
| |
| // ----- |
| |
| Constraint MultiConstraint(arg1: Value, arg2: Value); |
| |
| Pattern { |
| // CHECK: `Constraint`s applied via a variable constraint list must take a single input, but got 2 |
| let foo: MultiConstraint; |
| } |
| |
| // ----- |
| |
| #include "include/ops.td" |
| |
| Pattern { |
| // CHECK: unable to convert expression of type `Op<test.all_empty>` to the expected type of `Value` |
| // CHECK: see the definition of `test.all_empty`, which was defined with zero results |
| let value: Value = op<test.all_empty>; |
| erase _: Op; |
| } |
| |
| // ----- |
| |
| #include "include/ops.td" |
| |
| Pattern { |
| // CHECK: unable to convert expression of type `Op<test.multiple_single_result>` to the expected type of `Value` |
| // CHECK: see the definition of `test.multiple_single_result`, which was defined with at least 2 results |
| let value: Value = op<test.multiple_single_result>; |
| erase _: Op; |
| } |
| |
| // ----- |
| |
| //===----------------------------------------------------------------------===// |
| // `replace` |
| //===----------------------------------------------------------------------===// |
| |
| Pattern { |
| // CHECK: expected `Op` expression |
| replace attr<""> with attr<"">; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `with` after root operation |
| replace op<>; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `Op`, `Value` or `ValueRange` expression |
| replace op<> with attr<"">; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `Op`, `Value` or `ValueRange` expression |
| replace op<> with (attr<"">); |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `)` after replacement values |
| replace op<>(input: Value) with (input; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected at least one replacement value, consider using `erase` if no replacement values are desired |
| replace op<>(input: Value) with (); |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected dialect namespace |
| replace op<>(input: Value) with op<>; |
| } |
| |
| // ----- |
| |
| //===----------------------------------------------------------------------===// |
| // `return` |
| //===----------------------------------------------------------------------===// |
| |
| // CHECK: expected `;` after statement |
| Constraint Foo(arg: Value) -> Value { |
| return arg |
| } |
| |
| // ----- |
| |
| //===----------------------------------------------------------------------===// |
| // `rewrite` |
| //===----------------------------------------------------------------------===// |
| |
| Pattern { |
| // CHECK: expected `Op` expression |
| rewrite attr<""> with { op<toy.reshape>; }; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `with` before rewrite body |
| rewrite op<>; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected `{` to start rewrite body |
| rewrite op<> with; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: expected dialect namespace |
| rewrite root: Op with { |
| op<>; |
| }; |
| } |
| |
| // ----- |
| |
| Pattern { |
| // CHECK: `return` statements are only permitted within a `Constraint` or `Rewrite` body |
| rewrite root: Op with { |
| return root; |
| }; |
| } |