mlir/test/mlir-pdll/Parser/expr.pdll

   1 // RUN: mlir-pdll %s -I %S -I %S/../../../include -split-input-file | FileCheck %s
   2
   3 //===----------------------------------------------------------------------===//
   4 // AttrExpr
   5 //===----------------------------------------------------------------------===//
   6
   7 // CHECK: Module
   8 // CHECK: `-AttributeExpr {{.*}} Value<"10: i32">
   9 Pattern {
  10   let attr = attr<"10: i32">;
  11
  12   erase _: Op;
  13 }
  14
  15 // -----
  16
  17 //===----------------------------------------------------------------------===//
  18 // CallExpr
  19 //===----------------------------------------------------------------------===//
  20
  21 // CHECK: Module
  22 // CHECK: |-UserConstraintDecl {{.*}} Name<MakeRootOp> ResultType<Op<my_dialect.foo>>
  23 // CHECK:   `-CallExpr {{.*}} Type<Op<my_dialect.foo>>
  24 // CHECK:     `-DeclRefExpr {{.*}} Type<Constraint>
  25 // CHECK:       `-UserConstraintDecl {{.*}} Name<MakeRootOp> ResultType<Op<my_dialect.foo>>
  26 Constraint MakeRootOp() => op<my_dialect.foo>;
  27
  28 Pattern {
  29   erase MakeRootOp();
  30 }
  31
  32 // -----
  33
  34 // CHECK: Module
  35 // CHECK: |-UserRewriteDecl {{.*}} Name<CreateNewOp> ResultType<Op<my_dialect.foo>>
  36 // CHECK: `-PatternDecl {{.*}}
  37 // CHECK:   `-CallExpr {{.*}} Type<Op<my_dialect.foo>>
  38 // CHECK:     `-DeclRefExpr {{.*}} Type<Rewrite>
  39 // CHECK:       `-UserRewriteDecl {{.*}} Name<CreateNewOp> ResultType<Op<my_dialect.foo>>
  40 // CHECK:     `Arguments`
  41 // CHECK:       `-MemberAccessExpr {{.*}} Member<$results> Type<ValueRange>
  42 // CHECK:         `-DeclRefExpr {{.*}} Type<Op<my_dialect.bar>>
  43 // CHECK:           `-VariableDecl {{.*}} Name<inputOp> Type<Op<my_dialect.bar>>
  44 Rewrite CreateNewOp(inputs: ValueRange) => op<my_dialect.foo>(inputs);
  45
  46 Pattern {
  47   let inputOp = op<my_dialect.bar>;
  48   replace op<my_dialect.bar>(inputOp) with CreateNewOp(inputOp);
  49 }
  50
  51 // -----
  52
  53 // CHECK: Module {{.*}}
  54 // CHECK:  -UserConstraintDecl {{.*}} Name<TestConstraint> ResultType<Tuple<>>
  55 // CHECK: `-PatternDecl {{.*}}
  56 // CHECK:   -CallExpr {{.*}} Type<Tuple<>> Negated
  57 // CHECK:     `-DeclRefExpr {{.*}} Type<Constraint>
  58 // CHECK:       `-UserConstraintDecl {{.*}} Name<TestConstraint> ResultType<Tuple<>>
  59 Constraint TestConstraint(op: Op);
  60
  61 Pattern {
  62   let inputOp = op<my_dialect.bar>;
  63   not TestConstraint(inputOp);
  64   erase inputOp;
  65 }
  66
  67 // -----
  68
  69 //===----------------------------------------------------------------------===//
  70 // MemberAccessExpr
  71 //===----------------------------------------------------------------------===//
  72
  73 // CHECK: Module
  74 // CHECK: `-VariableDecl {{.*}} Name<firstEltIndex> Type<Op>
  75 // CHECK:   `-MemberAccessExpr {{.*}} Member<0> Type<Op>
  76 // CHECK:     `-DeclRefExpr {{.*}} Type<Tuple<firstElt: Op>>
  77 // CHECK: `-VariableDecl {{.*}} Name<firstEltName> Type<Op>
  78 // CHECK:   `-MemberAccessExpr {{.*}} Member<firstElt> Type<Op>
  79 // CHECK:     `-DeclRefExpr {{.*}} Type<Tuple<firstElt: Op>>
  80 Pattern {
  81   let tuple = (firstElt = _: Op);
  82   let firstEltIndex = tuple.0;
  83   let firstEltName = tuple.firstElt;
  84
  85   erase _: Op;
  86 }
  87
  88 // -----
  89
  90 #include "include/ops.td"
  91
  92 // CHECK: Module
  93 // CHECK: `-VariableDecl {{.*}} Name<firstEltIndex> Type<Value>
  94 // CHECK:   `-MemberAccessExpr {{.*}} Member<0> Type<Value>
  95 // CHECK:     `-DeclRefExpr {{.*}} Type<Op<test.all_single>>
  96 // CHECK: `-VariableDecl {{.*}} Name<firstEltName> Type<Value>
  97 // CHECK:   `-MemberAccessExpr {{.*}} Member<result> Type<Value>
  98 // CHECK:     `-DeclRefExpr {{.*}} Type<Op<test.all_single>>
  99 Pattern {
 100   let op: Op<test.all_single>;
 101   let firstEltIndex = op.0;
 102   let firstEltName = op.result;
 103
 104   erase op;
 105 }
 106
 107 // -----
 108
 109 // CHECK: Module
 110 // CHECK: `-VariableDecl {{.*}} Name<op> Type<Op<my_dialect.unregistered_foo>>
 111 // CHECK:   `-OperationExpr {{.*}} Type<Op<my_dialect.unregistered_foo>>
 112 // CHECK:     `-OpNameDecl {{.*}} Name<my_dialect.unregistered_foo>
 113 // CHECK:     `Operands`
 114 // CHECK:       `-MemberAccessExpr {{.*}} Member<0> Type<Value>
 115 // CHECK:         `-OperationExpr {{.*}} Type<Op<my_dialect.unregistered_bar>>
 116 // CHECK:           `-OpNameDecl {{.*}} Name<my_dialect.unregistered_bar>
 117 // CHECK:           `Operands`
 118 // CHECK:             `-DeclRefExpr {{.*}} Type<ValueRange>
 119 // CHECK:               `-VariableDecl {{.*}} Name<_> Type<ValueRange>
 120 // CHECK:                 `Constraints`
 121 // CHECK:                   `-ValueRangeConstraintDecl
 122 Pattern {
 123   let op = op<my_dialect.unregistered_foo>(op<my_dialect.unregistered_bar>.0);
 124   erase op;
 125 }
 126
 127 // -----
 128
 129 //===----------------------------------------------------------------------===//
 130 // OperationExpr
 131 //===----------------------------------------------------------------------===//
 132
 133 // Test a non-constrained operation expression, and ensure that we don't treat
 134 // unconstrained as "not present"(e.g. zero operands).
 135
 136 // CHECK: Module
 137 // CHECK: `-OperationExpr {{.*}} Type<Op>
 138 // CHECK:   `-OpNameDecl
 139 // CHECK:   `Operands`
 140 // CHECK:     `-DeclRefExpr {{.*}} Type<ValueRange>
 141 // CHECK:       `-VariableDecl {{.*}} Name<_> Type<ValueRange>
 142 // CHECK:         `Constraints`
 143 // CHECK:           `-ValueRangeConstraintDecl
 144 // CHECK:   `Result Types`
 145 // CHECK:     `-DeclRefExpr {{.*}} Type<TypeRange>
 146 // CHECK:       `-VariableDecl {{.*}} Name<_> Type<TypeRange>
 147 // CHECK:         `Constraints`
 148 // CHECK:           `-TypeRangeConstraintDecl
 149 Pattern {
 150   erase op<>;
 151 }
 152
 153 // -----
 154
 155 // Test explicitly empty operand/result/etc. lists, which are different from the
 156 // "unconstrained" examples above.
 157
 158 // CHECK: Module
 159 // CHECK: `-OperationExpr {{.*}} Type<Op>
 160 // CHECK:   `-OpNameDecl
 161 // CHECK-NOT: `Operands`
 162 // CHECK-NOT: `Result Types`
 163 Pattern {
 164   erase op<>() -> ();
 165 }
 166
 167 // -----
 168
 169 // CHECK: Module
 170 // CHECK: `-OperationExpr {{.*}} Type<Op<my_dialect.foo>>
 171 // CHECK:   `-OpNameDecl {{.*}} Name<my_dialect.foo>
 172 Pattern {
 173   erase op<my_dialect.foo>;
 174 }
 175
 176 // -----
 177
 178 // CHECK: Module
 179 // CHECK: `-OperationExpr {{.*}} Type<Op>
 180 // CHECK:   `-OpNameDecl
 181 // CHECK:   `Operands`
 182 // CHECK:     |-DeclRefExpr {{.*}} Type<Value>
 183 // CHECK:     |-DeclRefExpr {{.*}} Type<ValueRange>
 184 // CHECK:     `-DeclRefExpr {{.*}} Type<Value>
 185 Pattern {
 186   erase op<>(_: Value, _: ValueRange, _: Value);
 187 }
 188
 189 // -----
 190
 191 // CHECK: Module
 192 // CHECK: `-OperationExpr {{.*}} Type<Op>
 193 // CHECK:   `-OpNameDecl
 194 // CHECK:   `Operands`
 195 // CHECK:     `-MemberAccessExpr {{.*}} Member<$results> Type<ValueRange>
 196 // CHECK:       `-OperationExpr {{.*}} Type<Op<my_dialect.bar>>
 197 // CHECK:         `-OpNameDecl {{.*}} Name<my_dialect.bar>
 198 Pattern {
 199   erase op<>(op<my_dialect.bar>);
 200 }
 201
 202 // -----
 203
 204 // CHECK: Module
 205 // CHECK: `-OperationExpr {{.*}} Type<Op>
 206 // CHECK:   `-OpNameDecl
 207 // CHECK:   `Attributes`
 208 // CHECK:     |-NamedAttributeDecl {{.*}} Name<unitAttr>
 209 // CHECK:       `-AttributeExpr {{.*}} Value<"unit">
 210 // CHECK:     `-NamedAttributeDecl {{.*}} Name<normal$Attr>
 211 // CHECK:       `-DeclRefExpr {{.*}} Type<Attr>
 212
 213 Pattern {
 214   erase op<> {unitAttr, "normal$Attr" = _: Attr};
 215 }
 216
 217 // -----
 218
 219 // CHECK: Module
 220 // CHECK: `-OperationExpr {{.*}} Type<Op>
 221 // CHECK:   `-OpNameDecl
 222 // CHECK:   `Result Types`
 223 // CHECK:     |-DeclRefExpr {{.*}} Type<Type>
 224 // CHECK:     |-DeclRefExpr {{.*}} Type<TypeRange>
 225 // CHECK:     `-DeclRefExpr {{.*}} Type<Type>
 226 Pattern {
 227   erase op<> -> (_: Type, _: TypeRange, _: Type);
 228 }
 229
 230 // -----
 231
 232 // Test that we don't need to provide values if all elements
 233 // are optional.
 234
 235 #include "include/ops.td"
 236
 237 // CHECK: Module
 238 // CHECK:  -OperationExpr {{.*}} Type<Op<test.multi_variadic>>
 239 // CHECK-NOT:   `Operands`
 240 // CHECK-NOT:   `Result Types`
 241 // CHECK:  -OperationExpr {{.*}} Type<Op<test.all_variadic>>
 242 // CHECK-NOT:   `Operands`
 243 // CHECK-NOT:   `Result Types`
 244 // CHECK:  -OperationExpr {{.*}} Type<Op<test.multi_variadic>>
 245 // CHECK:    `Operands`
 246 // CHECK:      -RangeExpr {{.*}} Type<ValueRange>
 247 // CHECK:      -RangeExpr {{.*}} Type<ValueRange>
 248 // CHECK:    `Result Types`
 249 // CHECK:      -RangeExpr {{.*}} Type<TypeRange>
 250 // CHECK:      -RangeExpr {{.*}} Type<TypeRange>
 251 Pattern {
 252   rewrite op<test.multi_variadic>() -> () with {
 253     op<test.all_variadic> -> ();
 254     op<test.multi_variadic> -> ();
 255   };
 256 }
 257
 258 // -----
 259
 260 //===----------------------------------------------------------------------===//
 261 // TupleExpr
 262 //===----------------------------------------------------------------------===//
 263
 264 // CHECK: Module
 265 // CHECK: `-VariableDecl {{.*}} Name<emptyTuple>
 266 // CHECK:   `-TupleExpr {{.*}} Type<Tuple<>>
 267 // CHECK: `-VariableDecl {{.*}} Name<mixedTuple>
 268 // CHECK:   `-TupleExpr {{.*}} Type<Tuple<arg1: Attr, Value>>
 269 // CHECK:     |-DeclRefExpr {{.*}} Type<Attr>
 270 // CHECK:     `-DeclRefExpr {{.*}} Type<Value>
 271 Pattern {
 272   let value: Value;
 273
 274   let emptyTuple = ();
 275   let mixedTuple = (arg1 = _: Attr, value);
 276
 277   erase _: Op;
 278 }
 279
 280 // -----
 281
 282 //===----------------------------------------------------------------------===//
 283 // RangeExpr
 284 //===----------------------------------------------------------------------===//
 285
 286 // CHECK: Module
 287 // CHECK: `Operands`
 288 // CHECK:   -RangeExpr {{.*}} Type<ValueRange>
 289 // CHECK:   -RangeExpr {{.*}} Type<ValueRange>
 290 // CHECK:     -MemberAccessExpr {{.*}} Member<0> Type<Value>
 291 // CHECK:     -MemberAccessExpr {{.*}} Member<1> Type<ValueRange>
 292 // CHECK: `Result Types`
 293 // CHECK:   -RangeExpr {{.*}} Type<TypeRange>
 294 // CHECK:   -RangeExpr {{.*}} Type<TypeRange>
 295 // CHECK:     -MemberAccessExpr {{.*}} Member<0> Type<Type>
 296 // CHECK:     -MemberAccessExpr {{.*}} Member<1> Type<TypeRange>
 297 Pattern {
 298   rewrite op<>(arg: Value, args: ValueRange) -> (type: Type, types: TypeRange) with {
 299     op<test.op>((), (arg, args)) -> ((), (type, types));
 300   };
 301 }
 302
 303 // -----
 304
 305 //===----------------------------------------------------------------------===//
 306 // TypeExpr
 307 //===----------------------------------------------------------------------===//
 308
 309 // CHECK: Module
 310 // CHECK: `-TypeExpr {{.*}} Value<"i64">
 311 Pattern {
 312   let type = type<"i64">;
 313
 314   erase _: Op;
 315 }