// 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<"";
}