[mlir:PDLL] Add support for building a range from a tuple within a rewrite

[rriddle]

Summary

This allows for constructing type and value ranges from various sub elements,
which makes it easier to construct operations that take a range as an operand
or result type. Range construction is currently limited to within rewrites, to match
the current constraint on the PDL side.

mlir/include/mlir/Tools/PDLL/AST/Nodes.h

private:
   /// TrailingObject utilities.
   friend llvm::TrailingObjects<OperationExpr, Expr *, NamedAttributeDecl *>;
   size_t numTrailingObjects(OverloadToken<Expr *>) const {
     return numOperands + numResultTypes;
   }
 };
 
 //===----------------------------------------------------------------------===//
+// RangeExpr
+//===----------------------------------------------------------------------===//
+
+/// This expression builds a range from a set of element values (which may be
+/// ranges themselves).
+class RangeExpr final : public Node::NodeBase<RangeExpr, Expr>,
+                        private llvm::TrailingObjects<RangeExpr, Expr *> {
+public:
+  static RangeExpr *create(Context &ctx, SMRange loc, ArrayRef<Expr *> elements,
+                           RangeType type);
+
+  /// Return the element expressions of this range.
+  MutableArrayRef<Expr *> getElements() {
+    return {getTrailingObjects<Expr *>(), numElements};
+  }
+  ArrayRef<Expr *> getElements() const {
+    return const_cast<RangeExpr *>(this)->getElements();
+  }
+
+  /// Return the range result type of this expression.
+  RangeType getType() const { return Base::getType().cast<RangeType>(); }
+
+private:
+  RangeExpr(SMRange loc, RangeType type, unsigned numElements)
+      : Base(loc, type), numElements(numElements) {}
+
+  /// The number of element values for this range.
+  unsigned numElements;
+
+  /// TrailingObject utilities.
+  friend class llvm::TrailingObjects<RangeExpr, Expr *>;
+};
+
+//===----------------------------------------------------------------------===//
 // TupleExpr
 //===----------------------------------------------------------------------===//
 
 /// This expression builds a tuple from a set of element values.
 class TupleExpr final : public Node::NodeBase<TupleExpr, Expr>,
                         private llvm::TrailingObjects<TupleExpr, Expr *> {
 public:
   static TupleExpr *create(Context &ctx, SMRange loc, ArrayRef<Expr *> elements,

 inline bool CoreConstraintDecl::classof(const Node *node) {
   return isa<AttrConstraintDecl, OpConstraintDecl, TypeConstraintDecl,
              TypeRangeConstraintDecl, ValueConstraintDecl,
              ValueRangeConstraintDecl>(node);
 }
 
 inline bool Expr::classof(const Node *node) {
   return isa<AttributeExpr, CallExpr, DeclRefExpr, MemberAccessExpr,
-             OperationExpr, TupleExpr, TypeExpr>(node);
+             OperationExpr, RangeExpr, TupleExpr, TypeExpr>(node);
 }
 
 inline bool OpRewriteStmt::classof(const Node *node) {
   return isa<EraseStmt, ReplaceStmt, RewriteStmt>(node);
 }
 
 inline bool Stmt::classof(const Node *node) {
   return isa<CompoundStmt, LetStmt, OpRewriteStmt, Expr>(node);
 }
 
 } // namespace ast
 } // namespace pdll
 } // namespace mlir
 
 #endif // MLIR_TOOLS_PDLL_AST_NODES_H_

mlir/lib/Tools/PDLL/AST/NodePrinter.cpp

private:
   void printImpl(const ReturnStmt *stmt);
   void printImpl(const RewriteStmt *stmt);
 
   void printImpl(const AttributeExpr *expr);
   void printImpl(const CallExpr *expr);
   void printImpl(const DeclRefExpr *expr);
   void printImpl(const MemberAccessExpr *expr);
   void printImpl(const OperationExpr *expr);
+  void printImpl(const RangeExpr *expr);
   void printImpl(const TupleExpr *expr);
   void printImpl(const TypeExpr *expr);
 
   void printImpl(const AttrConstraintDecl *decl);
   void printImpl(const OpConstraintDecl *decl);
   void printImpl(const TypeConstraintDecl *decl);
   void printImpl(const TypeRangeConstraintDecl *decl);
   void printImpl(const UserConstraintDecl *decl);
void NodePrinter::print(const Node *node) {
   TypeSwitch<const Node *>(node)
       .Case<
           // Statements.
           const CompoundStmt, const EraseStmt, const LetStmt, const ReplaceStmt,
           const ReturnStmt, const RewriteStmt,
 
           // Expressions.
           const AttributeExpr, const CallExpr, const DeclRefExpr,
-          const MemberAccessExpr, const OperationExpr, const TupleExpr,
-          const TypeExpr,
+          const MemberAccessExpr, const OperationExpr, const RangeExpr,
+          const TupleExpr, const TypeExpr,
 
           // Decls.
           const AttrConstraintDecl, const OpConstraintDecl,
           const TypeConstraintDecl, const TypeRangeConstraintDecl,
           const UserConstraintDecl, const ValueConstraintDecl,
           const ValueRangeConstraintDecl, const NamedAttributeDecl,
           const OpNameDecl, const PatternDecl, const UserRewriteDecl,
           const VariableDecl,
void NodePrinter::printImpl(const OperationExpr *expr) {
   os << ">\n";
 
   printChildren(expr->getNameDecl());
   printChildren("Operands", expr->getOperands());
   printChildren("Result Types", expr->getResultTypes());
   printChildren("Attributes", expr->getAttributes());
 }
 
+void NodePrinter::printImpl(const RangeExpr *expr) {
+  os << "RangeExpr " << expr << " Type<";
+  print(expr->getType());
+  os << ">\n";
+
+  printChildren(expr->getElements());
+}
+
 void NodePrinter::printImpl(const TupleExpr *expr) {
   os << "TupleExpr " << expr << " Type<";
   print(expr->getType());
   os << ">\n";
 
   printChildren(expr->getElements());
 }
 

mlir/lib/Tools/PDLL/AST/Nodes.cpp

void visit(const Node *node) {
     TypeSwitch<const Node *>(node)
         .Case<
             // Statements.
             const CompoundStmt, const EraseStmt, const LetStmt,
             const ReplaceStmt, const ReturnStmt, const RewriteStmt,
 
             // Expressions.
             const AttributeExpr, const CallExpr, const DeclRefExpr,
-            const MemberAccessExpr, const OperationExpr, const TupleExpr,
-            const TypeExpr,
+            const MemberAccessExpr, const OperationExpr, const RangeExpr,
+            const TupleExpr, const TypeExpr,
 
             // Core Constraint Decls.
             const AttrConstraintDecl, const OpConstraintDecl,
             const TypeConstraintDecl, const TypeRangeConstraintDecl,
             const ValueConstraintDecl, const ValueRangeConstraintDecl,
 
             // Decls.
             const NamedAttributeDecl, const OpNameDecl, const PatternDecl,
void visitImpl(const OperationExpr *expr) {
     visit(expr->getNameDecl());
     for (const Node *child : expr->getOperands())
       visit(child);
     for (const Node *child : expr->getResultTypes())
       visit(child);
     for (const Node *child : expr->getAttributes())
       visit(child);
   }
+  void visitImpl(const RangeExpr *expr) {
+    for (const Node *child : expr->getElements())
+      visit(child);
+  }
   void visitImpl(const TupleExpr *expr) {
     for (const Node *child : expr->getElements())
       visit(child);
   }
   void visitImpl(const TypeExpr *expr) {}
 
   void visitImpl(const AttrConstraintDecl *decl) { visit(decl->getTypeExpr()); }
   void visitImpl(const OpConstraintDecl *decl) { visit(decl->getNameDecl()); }
OperationExpr::create(Context &ctx, SMRange loc, const ods::Operation *odsOp,
   return opExpr;
 }
 
 Optional<StringRef> OperationExpr::getName() const {
   return getNameDecl()->getName();
 }
 
 //===----------------------------------------------------------------------===//
+// RangeExpr
+//===----------------------------------------------------------------------===//
+
+RangeExpr *RangeExpr::create(Context &ctx, SMRange loc,
+                             ArrayRef<Expr *> elements, RangeType type) {
+  unsigned allocSize = RangeExpr::totalSizeToAlloc<Expr *>(elements.size());
+  void *rawData = ctx.getAllocator().Allocate(allocSize, alignof(TupleExpr));
+
+  RangeExpr *expr = new (rawData) RangeExpr(loc, type, elements.size());
+  std::uninitialized_copy(elements.begin(), elements.end(),
+                          expr->getElements().begin());
+  return expr;
+}
+
+//===----------------------------------------------------------------------===//
 // TupleExpr
 //===----------------------------------------------------------------------===//
 
 TupleExpr *TupleExpr::create(Context &ctx, SMRange loc,
                              ArrayRef<Expr *> elements,
                              ArrayRef<StringRef> names) {
   unsigned allocSize = TupleExpr::totalSizeToAlloc<Expr *>(elements.size());
   void *rawData = ctx.getAllocator().Allocate(allocSize, alignof(TupleExpr));

mlir/lib/Tools/PDLL/CodeGen/MLIRGen.cpp

private:
 
   Value genSingleExpr(const ast::Expr *expr);
   SmallVector<Value> genExpr(const ast::Expr *expr);
   Value genExprImpl(const ast::AttributeExpr *expr);
   SmallVector<Value> genExprImpl(const ast::CallExpr *expr);
   SmallVector<Value> genExprImpl(const ast::DeclRefExpr *expr);
   Value genExprImpl(const ast::MemberAccessExpr *expr);
   Value genExprImpl(const ast::OperationExpr *expr);
+  Value genExprImpl(const ast::RangeExpr *expr);
   SmallVector<Value> genExprImpl(const ast::TupleExpr *expr);
   Value genExprImpl(const ast::TypeExpr *expr);
 
   SmallVector<Value> genConstraintCall(const ast::UserConstraintDecl *decl,
                                        Location loc, ValueRange inputs);
   SmallVector<Value> genRewriteCall(const ast::UserRewriteDecl *decl,
                                     Location loc, ValueRange inputs);
   template <typename PDLOpT, typename T>

 
 //===----------------------------------------------------------------------===//
 // CodeGen: Expressions
 //===----------------------------------------------------------------------===//
 
 Value CodeGen::genSingleExpr(const ast::Expr *expr) {
   return TypeSwitch<const ast::Expr *, Value>(expr)
       .Case<const ast::AttributeExpr, const ast::MemberAccessExpr,
-            const ast::OperationExpr, const ast::TypeExpr>(
+            const ast::OperationExpr, const ast::RangeExpr,
+            const ast::TypeExpr>(
           [&](auto derivedNode) { return this->genExprImpl(derivedNode); })
       .Case<const ast::CallExpr, const ast::DeclRefExpr, const ast::TupleExpr>(
           [&](auto derivedNode) {
             SmallVector<Value> results = this->genExprImpl(derivedNode);
             assert(results.size() == 1 && "expected single expression result");
             return results[0];
           });
 }
Value CodeGen::genExprImpl(const ast::OperationExpr *expr) {
   SmallVector<Value> results;
   for (const ast::Expr *result : expr->getResultTypes())
     results.push_back(genSingleExpr(result));
 
   return builder.create<pdl::OperationOp>(loc, opName, operands, attrNames,
                                           attrValues, results);
 }
 
+Value CodeGen::genExprImpl(const ast::RangeExpr *expr) {
+  SmallVector<Value> elements;
+  for (const ast::Expr *element : expr->getElements())
+    llvm::append_range(elements, genExpr(element));
+
+  return builder.create<pdl::RangeOp>(genLoc(expr->getLoc()),
+                                      genType(expr->getType()), elements);
+}
+
 SmallVector<Value> CodeGen::genExprImpl(const ast::TupleExpr *expr) {
   SmallVector<Value> elements;
   for (const ast::Expr *element : expr->getElements())
     elements.push_back(genSingleExpr(element));
   return elements;
 }
 
 Value CodeGen::genExprImpl(const ast::TypeExpr *expr) {

mlir/lib/Tools/PDLL/Parser/Parser.cpp

 
 namespace {
 class Parser {
 public:
   Parser(ast::Context &ctx, llvm::SourceMgr &sourceMgr,
          bool enableDocumentation, CodeCompleteContext *codeCompleteContext)
       : ctx(ctx), lexer(sourceMgr, ctx.getDiagEngine(), codeCompleteContext),
         curToken(lexer.lexToken()), enableDocumentation(enableDocumentation),
-        valueTy(ast::ValueType::get(ctx)),
-        valueRangeTy(ast::ValueRangeType::get(ctx)),
-        typeTy(ast::TypeType::get(ctx)),
+        typeTy(ast::TypeType::get(ctx)), valueTy(ast::ValueType::get(ctx)),
         typeRangeTy(ast::TypeRangeType::get(ctx)),
+        valueRangeTy(ast::ValueRangeType::get(ctx)),
         attrTy(ast::AttributeType::get(ctx)),
         codeCompleteContext(codeCompleteContext) {}
 
   /// Try to parse a new module. Returns nullptr in the case of failure.
   FailureOr<ast::Module *> parseModule();
 
 private:
   /// The current context of the parser. It allows for the parser to know a bit
private:
 
   /// Try to convert the given expression to `type`. Returns failure and emits
   /// an error if a conversion is not viable. On failure, `noteAttachFn` is
   /// invoked to attach notes to the emitted error diagnostic. On success,
   /// `expr` is updated to the expression used to convert to `type`.
   LogicalResult convertExpressionTo(
       ast::Expr *&expr, ast::Type type,
       function_ref<void(ast::Diagnostic &diag)> noteAttachFn = {});
+  LogicalResult
+  convertOpExpressionTo(ast::Expr *&expr, ast::OperationType exprType,
+                        ast::Type type,
+                        function_ref<ast::InFlightDiagnostic()> emitErrorFn);
+  LogicalResult convertTupleExpressionTo(
+      ast::Expr *&expr, ast::TupleType exprType, ast::Type type,
+      function_ref<ast::InFlightDiagnostic()> emitErrorFn,
+      function_ref<void(ast::Diagnostic &diag)> noteAttachFn);
 
   /// Given an operation expression, convert it to a Value or ValueRange
   /// typed expression.
   ast::Expr *convertOpToValue(const ast::Expr *opExpr);
 
   /// Lookup ODS information for the given operation, returns nullptr if no
   /// information is found.
   const ods::Operation *lookupODSOperation(Optional<StringRef> opName) {
private:
   /// The most recently defined decl scope.
   ast::DeclScope *curDeclScope = nullptr;
   llvm::SpecificBumpPtrAllocator<ast::DeclScope> scopeAllocator;
 
   /// The current context of the parser.
   ParserContext parserContext = ParserContext::Global;
 
   /// Cached types to simplify verification and expression creation.
-  ast::Type valueTy, valueRangeTy;
-  ast::Type typeTy, typeRangeTy;
+  ast::Type typeTy, valueTy;
+  ast::RangeType typeRangeTy, valueRangeTy;
   ast::Type attrTy;
 
   /// A counter used when naming anonymous constraints and rewrites.
   unsigned anonymousDeclNameCounter = 0;
 
   /// The optional code completion context.
   CodeCompleteContext *codeCompleteContext;
 };
ast::InFlightDiagnostic diag = ctx.getDiagEngine().emitError(
                                       "`{0}` to the expected type of "
                                       "`{1}`",
                                       exprType, type));
     if (noteAttachFn)
       noteAttachFn(*diag);
     return diag;
   };
 
-  if (auto exprOpType = exprType.dyn_cast<ast::OperationType>()) {
-    // Two operation types are compatible if they have the same name, or if the
-    // expected type is more general.
-    if (auto opType = type.dyn_cast<ast::OperationType>()) {
-      if (opType.getName())
-        return emitConvertError();
-      return success();
-    }
+  if (auto exprOpType = exprType.dyn_cast<ast::OperationType>())
+    return convertOpExpressionTo(expr, exprOpType, type, emitConvertError);
+
+  // FIXME: Decide how to allow/support converting a single result to multiple,
+  // and multiple to a single result. For now, we just allow Single->Range,
+  // but this isn't something really supported in the PDL dialect. We should
+  // figure out some way to support both.
+  if ((exprType == valueTy || exprType == valueRangeTy) &&
+      (type == valueTy || type == valueRangeTy))
+    return success();
+  if ((exprType == typeTy || exprType == typeRangeTy) &&
+      (type == typeTy || type == typeRangeTy))
+    return success();
+
+  // Handle tuple types.
+  if (auto exprTupleType = exprType.dyn_cast<ast::TupleType>())
+    return convertTupleExpressionTo(expr, exprTupleType, type, emitConvertError,
+                                    noteAttachFn);
+
+  return emitConvertError();
+}
+
+LogicalResult Parser::convertOpExpressionTo(
+    ast::Expr *&expr, ast::OperationType exprType, ast::Type type,
+    function_ref<ast::InFlightDiagnostic()> emitErrorFn) {
+      return emitErrorFn();
 
-    // An operation can always convert to a ValueRange.
-    if (type == valueRangeTy) {
-      expr = ast::AllResultsMemberAccessExpr::create(ctx, expr->getLoc(), expr,
-                                                     valueRangeTy);
-      return success();
-    }
 
-    // Allow conversion to a single value by constraining the result range.
-    if (type == valueTy) {
-      // If the operation is registered, we can verify if it can ever have a
-      // single result.
-      if (const ods::Operation *odsOp = exprOpType.getODSOperation()) {
-        if (odsOp->getResults().empty()) {
-          return emitConvertError()->attachNote(
-              llvm::formatv("see the definition of `{0}`, which was defined "
-                            "with zero results",
-                            odsOp->getName()),
-              odsOp->getLoc());
-        }
+    if (const ods::Operation *odsOp = exprType.getODSOperation()) {
+        return emitErrorFn()->attachNote(
 
-        unsigned numSingleResults = llvm::count_if(
-            odsOp->getResults(), [](const ods::OperandOrResult &result) {
-              return result.getVariableLengthKind() ==
-                     ods::VariableLengthKind::Single;
-            });
-        if (numSingleResults > 1) {
-          return emitConvertError()->attachNote(
-              llvm::formatv("see the definition of `{0}`, which was defined "
-                            "with at least {1} results",
-                            odsOp->getName(), numSingleResults),
-              odsOp->getLoc());
-        }
-      }
+        return emitErrorFn()->attachNote(
 
-      expr = ast::AllResultsMemberAccessExpr::create(ctx, expr->getLoc(), expr,
-                                                     valueTy);
-      return success();
-    }
-    return emitConvertError();
-  }
+  return emitErrorFn();
 
-  // FIXME: Decide how to allow/support converting a single result to multiple,
-  // and multiple to a single result. For now, we just allow Single->Range,
-  // but this isn't something really supported in the PDL dialect. We should
-  // figure out some way to support both.
-  if ((exprType == valueTy || exprType == valueRangeTy) &&
-      (type == valueTy || type == valueRangeTy))
-    return success();
-  if ((exprType == typeTy || exprType == typeRangeTy) &&
-      (type == typeTy || type == typeRangeTy))
-    return success();
-
-  // Handle tuple types.
-  if (auto exprTupleType = exprType.dyn_cast<ast::TupleType>()) {
-    auto tupleType = type.dyn_cast<ast::TupleType>();
-    if (!tupleType || tupleType.size() != exprTupleType.size())
-      return emitConvertError();
+LogicalResult Parser::convertTupleExpressionTo(
+    ast::Expr *&expr, ast::TupleType exprType, ast::Type type,
+    function_ref<ast::InFlightDiagnostic()> emitErrorFn,
+    function_ref<void(ast::Diagnostic &diag)> noteAttachFn) {
+  // Handle conversions between tuples.
+  if (auto tupleType = type.dyn_cast<ast::TupleType>()) {
+    if (tupleType.size() != exprType.size())
+      return emitErrorFn();
 
     // Build a new tuple expression using each of the elements of the current
     // tuple.
     SmallVector<ast::Expr *> newExprs;
-    for (unsigned i = 0, e = exprTupleType.size(); i < e; ++i) {
+    for (unsigned i = 0, e = exprType.size(); i < e; ++i) {
       newExprs.push_back(ast::MemberAccessExpr::create(
           ctx, expr->getLoc(), expr, llvm::to_string(i),
-          exprTupleType.getElementTypes()[i]));
+          exprType.getElementTypes()[i]));
 
       auto diagFn = [&](ast::Diagnostic &diag) {
         diag.attachNote(llvm::formatv("when converting element #{0} of `{1}`",
-                                      i, exprTupleType));
+                                      i, exprType));
         if (noteAttachFn)
           noteAttachFn(diag);
       };
       if (failed(convertExpressionTo(newExprs.back(),
                                      tupleType.getElementTypes()[i], diagFn)))
         return failure();
     }
     expr = ast::TupleExpr::create(ctx, expr->getLoc(), newExprs,
                                   tupleType.getElementNames());
     return success();
   }
 
-  return emitConvertError();
+  // Handle conversion to a range.
+  auto convertToRange = [&](ArrayRef<ast::Type> allowedElementTypes,
+                            ast::RangeType resultTy) -> LogicalResult {
+    // TODO: We currently only allow range conversion within a rewrite context.
+    if (parserContext != ParserContext::Rewrite) {
+      return emitErrorFn()->attachNote("Tuple to Range conversion is currently "
+                                       "only allowed within a rewrite context");
+    }
+
+    // All of the tuple elements must be allowed types.
+    for (ast::Type elementType : exprType.getElementTypes())
+      if (!llvm::is_contained(allowedElementTypes, elementType))
+        return emitErrorFn();
+
+    // Build a new tuple expression using each of the elements of the current
+    // tuple.
+    SmallVector<ast::Expr *> newExprs;
+    for (unsigned i = 0, e = exprType.size(); i < e; ++i) {
+      newExprs.push_back(ast::MemberAccessExpr::create(
+          ctx, expr->getLoc(), expr, llvm::to_string(i),
+          exprType.getElementTypes()[i]));
+    }
+    expr = ast::RangeExpr::create(ctx, expr->getLoc(), newExprs, resultTy);
+    return success();
+  };
+  if (type == valueRangeTy)
+    return convertToRange({valueTy, valueRangeTy}, valueRangeTy);
+  if (type == typeRangeTy)
+    return convertToRange({typeTy, typeRangeTy}, typeRangeTy);
+
+  return emitErrorFn();
 }
 
 //===----------------------------------------------------------------------===//
 // Directives
 
 LogicalResult Parser::parseDirective(SmallVectorImpl<ast::Decl *> &decls) {
   StringRef directive = curToken.getSpelling();
   if (directive == "#include")
for (ast::Expr *&valueExpr : values) {
     // expressions: `op<my_dialect.foo>(op<my_dialect.bar>)`
     if (singleTy == valueTy) {
       if (valueExprType.isa<ast::OperationType>()) {
         valueExpr = convertOpToValue(valueExpr);
         continue;
       }
     }
 
+    // Otherwise, try to convert the expression to a range.
+    if (succeeded(convertExpressionTo(valueExpr, rangeTy)))
+      continue;
+
     return emitError(
         valueExpr->getLoc(),
         llvm::formatv(
             "expected `{0}` or `{1}` convertible expression, but got `{2}`",
             singleTy, rangeTy, valueExprType));
   }
   return success();
 }

mlir/test/mlir-pdll/CodeGen/MLIR/expr.pdll

Pattern TupleMemberAccessName {
   let secondOp = op<test.second>(firstOp);
   let tuple = (first = firstOp, second = secondOp);
   replace tuple.first with tuple.second;
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
+// RangeExpr
+//===----------------------------------------------------------------------===//
+
+// CHECK: pdl.pattern @RangeExpr
+// CHECK: %[[ARG:.*]] = operand
+// CHECK: %[[ARGS:.*]] = operands
+// CHECK: %[[TYPE:.*]] = type
+// CHECK: %[[TYPES:.*]] = types
+// CHECK:   range : !pdl.range<value>
+// CHECK:   range %[[ARG]], %[[ARGS]] : !pdl.value, !pdl.range<value>
+// CHECK:   range : !pdl.range<type>
+// CHECK:   range %[[TYPE]], %[[TYPES]] : !pdl.type, !pdl.range<type>
+Pattern RangeExpr {
+  replace op<>(arg: Value, args: ValueRange) -> (type: Type, types: TypeRange)
+    with op<test.op>((), (arg, args)) -> ((), (type, types));
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
 // TypeExpr
 //===----------------------------------------------------------------------===//
 
 // CHECK: pdl.pattern @TypeExpr
 // CHECK: %[[TYPE:.*]] = type : i32
 // CHECK: operation({{.*}}) -> (%[[TYPE]] : !pdl.type)
 Pattern TypeExpr => erase op<> -> (type<"i32">);

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

Pattern {
   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;
 }
 

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

Pattern {
   let mixedTuple = (arg1 = _: Attr, value);
 
   erase _: Op;
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
+// RangeExpr
+//===----------------------------------------------------------------------===//
+
+// CHECK: Module
+// CHECK: `Operands`
+// CHECK:   -RangeExpr {{.*}} Type<ValueRange>
+// CHECK:   -RangeExpr {{.*}} Type<ValueRange>
+// CHECK:     -MemberAccessExpr {{.*}} Member<0> Type<Value>
+// CHECK:     -MemberAccessExpr {{.*}} Member<1> Type<ValueRange>
+// CHECK: `Result Types`
+// CHECK:   -RangeExpr {{.*}} Type<TypeRange>
+// CHECK:   -RangeExpr {{.*}} Type<TypeRange>
+// CHECK:     -MemberAccessExpr {{.*}} Member<0> Type<Type>
+// CHECK:     -MemberAccessExpr {{.*}} Member<1> Type<TypeRange>
+Pattern {
+  rewrite op<>(arg: Value, args: ValueRange) -> (type: Type, types: TypeRange) with {
+    op<test.op>((), (arg, args)) -> ((), (type, types));
+  };
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
 // TypeExpr
 //===----------------------------------------------------------------------===//
 
 // CHECK: Module
 // CHECK: `-TypeExpr {{.*}} Value<"i64">
 Pattern {
   let type = type<"i64">;
 
   erase _: Op;
 }