[mlir:PDL] Remove the ConstantParams support from native Constraints/Rewrites

[rriddle]

Summary

This support has never really worked well, and is incredibly clunky to
use (it effectively creates two argument APIs), and clunky to generate (it isn't
clear how we should actually expose this from PDL frontends). Treating these
as just attribute arguments is much much cleaner in every aspect of the stack.
If we need to optimize lots of constant parameters, it would be better to
investigate internal representation optimizations (e.g. batch attribute creation),
that do not affect the user (we want a clean external API).

[nicolasvasilache]

Thanks for the cleanup! This was probably premature indeed.

[jpienaar]

Makes sense, thanks!

mlir/docs/PDLL.md

 }
 ```
 
 External constraints are those registered explicitly with the `RewritePatternSet` via
 the C++ PDL API. For example, the constraints above may be registered as:
 
 ```c++
 // TODO: Cleanup when we allow more accessible wrappers around PDL functions.
-static LogicalResult hasOneUseImpl(PDLValue pdlValue, ArrayAttr constantParams,
-                                   PatternRewriter &rewriter) {
+static LogicalResult hasOneUseImpl(PDLValue pdlValue, PatternRewriter &rewriter) {
   Value value = pdlValue.cast<Value>();
   
   return success(value.hasOneUse());
 }
-static LogicalResult hasSameElementTypeImpl(
-    ArrayRef<PDLValue> pdlValues, ArrayAttr constantParams,
+static LogicalResult hasSameElementTypeImpl(ArrayRef<PDLValue> pdlValues,
                                             PatternRewriter &rewriter) {
   Value value1 = pdlValues[0].cast<Value>();
   Value value2 = pdlValues[1].cast<Value>();
       
   return success(value1.getType().cast<ShapedType>().getElementType() ==
                  value2.getType().cast<ShapedType>().getElementType());
 }
 
 void registerNativeConstraints(RewritePatternSet &patterns) {

 }
 ```
 
 External rewrites are those registered explicitly with the `RewritePatternSet` via
 the C++ PDL API. For example, the rewrite above may be registered as:
 
 ```c++
 // TODO: Cleanup when we allow more accessible wrappers around PDL functions.
-static void buildOpImpl(ArrayRef<PDLValue> args, ArrayAttr constantParams,
-                        PatternRewriter &rewriter, PDLResultList &results) {
+static void buildOpImpl(ArrayRef<PDLValue> args, PatternRewriter &rewriter,
+                        PDLResultList &results) {
   Value value = args[0].cast<Value>();
 
   // insert special rewrite logic here.
   Operation *resultOp = ...; 
   results.push_back(resultOp);
 }
 
 void registerNativeRewrite(RewritePatternSet &patterns) {

mlir/include/mlir/Dialect/PDL/IR/PDLOps.td

 //===----------------------------------------------------------------------===//
 
 def PDL_ApplyNativeConstraintOp
     : PDL_Op<"apply_native_constraint", [HasParent<"pdl::PatternOp">]> {
   let summary = "Apply a native constraint to a set of provided entities";
   let description = [{
     `pdl.apply_native_constraint` operations apply a native C++ constraint, that
     has been registered externally with the consumer of PDL, to a given set of
-    entities. The constraint is permitted to accept any number of constant
-    valued parameters.
+    entities.
 
     Example:
 
     ```mlir
-    // Apply `myConstraint` to the entities defined by `input`, `attr`, and
-    // `op`. `42`, `"abc"`, and `i32` are constant parameters passed to the
-    // constraint.
-    pdl.apply_native_constraint "myConstraint"[42, "abc", i32](%input, %attr, %op : !pdl.value, !pdl.attribute, !pdl.operation)
+    // Apply `myConstraint` to the entities defined by `input`, `attr`, and `op`.
+    pdl.apply_native_constraint "myConstraint"(%input, %attr, %op : !pdl.value, !pdl.attribute, !pdl.operation)
     ```
   }];
 
-  let arguments = (ins StrAttr:$name,
-                       Variadic<PDL_AnyType>:$args,
-                       OptionalAttr<ArrayAttr>:$constParams);
-  let assemblyFormat = [{
-    $name ($constParams^)? `(` $args `:` type($args) `)` attr-dict
-  }];
-
-  let builders = [
-    OpBuilder<(ins "StringRef":$name, CArg<"ValueRange", "{}">:$args,
-                   CArg<"ArrayRef<Attribute>", "{}">:$params), [{
-      build($_builder, $_state, $_builder.getStringAttr(name), args,
-            params.empty() ? ArrayAttr() : $_builder.getArrayAttr(params));
-    }]>,
-  ];
+  let arguments = (ins StrAttr:$name, Variadic<PDL_AnyType>:$args);
+  let assemblyFormat = "$name `(` $args `:` type($args) `)` attr-dict";
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ApplyNativeRewriteOp
 //===----------------------------------------------------------------------===//
 
 def PDL_ApplyNativeRewriteOp
     : PDL_Op<"apply_native_rewrite", [HasParent<"pdl::RewriteOp">]> {
   let summary = "Apply a native rewrite method inside of pdl.rewrite region";
   let description = [{
     `pdl.apply_native_rewrite` operations apply a native C++ function, that has
     been registered externally with the consumer of PDL, to perform a rewrite
     and optionally return a number of values. The native function may accept any
-    number of arguments and constant attribute parameters. This operation is
-    used within a pdl.rewrite region to enable the interleaving of native
-    rewrite methods with other pdl constructs.
+    number of arguments. This operation is used within a pdl.rewrite region to enable
+    the interleaving of native rewrite methods with other pdl constructs.
 
     Example:
 
     ```mlir
     // Apply a native rewrite method that returns an attribute.
-    %ret = pdl.apply_native_rewrite "myNativeFunc"[42, "gt"](%arg0, %arg1) : !pdl.attribute
+    %ret = pdl.apply_native_rewrite "myNativeFunc"(%arg0, %arg1) : !pdl.attribute
     ```
 
     ```c++
     // The native rewrite as defined in C++:
-    static void myNativeFunc(ArrayRef<PDLValue> args, ArrayAttr constantParams,
-                             PatternRewriter &rewriter,
+    static void myNativeFunc(ArrayRef<PDLValue> args, PatternRewriter &rewriter,
                              PDLResultList &results) {
       Value arg0 = args[0].cast<Value>();
       Value arg1 = args[1].cast<Value>();
-      IntegerAttr param0 = constantParams[0].cast<IntegerAttr>();
-      StringAttr param1 = constantParams[1].cast<StringAttr>();
 
       // Just push back the first param attribute.
       results.push_back(param0);
     }
 
     void registerNativeRewrite(PDLPatternModule &pdlModule) {
       pdlModule.registerRewriteFunction("myNativeFunc", myNativeFunc);
     }
     ```
   }];
 
-  let arguments = (ins StrAttr:$name,
-                       Variadic<PDL_AnyType>:$args,
-                       OptionalAttr<ArrayAttr>:$constParams);
+  let arguments = (ins StrAttr:$name, Variadic<PDL_AnyType>:$args);
   let results = (outs Variadic<PDL_AnyType>:$results);
   let assemblyFormat = [{
-    $name ($constParams^)? (`(` $args^ `:` type($args) `)`)?
-    (`:` type($results)^)? attr-dict
+    $name (`(` $args^ `:` type($args) `)`)? (`:` type($results)^)? attr-dict
   }];
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::AttributeOp
 //===----------------------------------------------------------------------===//
 
def PDL_RewriteOp : PDL_Op<"rewrite", [
   ]> {
   let summary = "Specify the rewrite of a matched pattern";
   let description = [{
     `pdl.rewrite` operations terminate the region of a `pdl.pattern` and specify
     the main rewrite of a `pdl.pattern`, on the optional root operation. The
     rewrite is specified either via a string name (`name`) to a native
     rewrite function, or via the region body. The rewrite region, if specified,
     must contain a single block. If the rewrite is external it functions
-    similarly to `pdl.apply_native_rewrite`, and takes a set of constant
-    parameters and a set of additional positional values defined within the
-    matcher as arguments. If the rewrite is external, the root operation is
-    passed to the native function as the leading arguments. The root operation,
-    if provided, specifies the starting point in the pattern for the subgraph
-    isomorphism search. Pattern matching will proceed from this node downward
-    (towards the defining operation) or upward (towards the users) until all
-    the operations in the pattern have been matched. If the root is omitted,
-    the pdl_interp lowering will automatically select the best root of the
-    pdl.rewrite among all the operations in the pattern.
+    similarly to `pdl.apply_native_rewrite`, and takes a set of additional
+    positional values defined within the matcher as arguments. If the rewrite is
+    external, the root operation is passed to the native function as the leading
+    arguments. The root operation, if provided, specifies the starting point in
+    the pattern for the subgraph isomorphism search. Pattern matching will proceed
+    from this node downward (towards the defining operation) or upward
+    (towards the users) until all the operations in the pattern have been matched.
+    If the root is omitted, the pdl_interp lowering will automatically select
+    the best root of the pdl.rewrite among all the operations in the pattern.
 
     Example:
 
     ```mlir
     // Specify an external rewrite function:
     pdl.rewrite %root with "myExternalRewriter"(%value : !pdl.value)
 
     // Specify a rewrite inline using PDL with the given root:
pdl.rewrite {
       pdl.replace %root1 with %op1
       pdl.replace %root2 with %op2
     }
     ```
   }];
 
   let arguments = (ins Optional<PDL_Operation>:$root,
                        OptionalAttr<StrAttr>:$name,
-                       Variadic<PDL_AnyType>:$externalArgs,
-                       OptionalAttr<ArrayAttr>:$externalConstParams);
+                       Variadic<PDL_AnyType>:$externalArgs);
   let regions = (region AnyRegion:$body);
   let assemblyFormat = [{
-    ($root^)? (`with` $name^ ($externalConstParams^)?
-                             (`(` $externalArgs^ `:` type($externalArgs) `)`)?)?
+    ($root^)? (`with` $name^ (`(` $externalArgs^ `:` type($externalArgs) `)`)?)?
               ($body^)?
     attr-dict-with-keyword
   }];
   let hasRegionVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypeOp

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

 // pdl_interp::ApplyConstraintOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_ApplyConstraintOp : PDLInterp_PredicateOp<"apply_constraint"> {
   let summary = "Apply a constraint to a set of positional values";
   let description = [{
     `pdl_interp.apply_constraint` operations apply a generic constraint, that
     has been registered with the interpreter, with a given set of positional
-    values. The constraint may have any number of constant parameters. On
-    success, this operation branches to the true destination, otherwise the
-    false destination is taken.
+    values. On success, this operation branches to the true destination,
+    otherwise the false destination is taken.
 
     Example:
 
     ```mlir
     // Apply `myConstraint` to the entities defined by `input`, `attr`, and
     // `op`.
-    pdl_interp.apply_constraint "myConstraint"[42, "abc", i32](%input, %attr, %op : !pdl.value, !pdl.attribute, !pdl.operation) -> ^matchDest, ^failureDest
+    pdl_interp.apply_constraint "myConstraint"(%input, %attr, %op : !pdl.value, !pdl.attribute, !pdl.operation) -> ^matchDest, ^failureDest
     ```
   }];
 
-  let arguments = (ins StrAttr:$name,
-                       Variadic<PDL_AnyType>:$args,
-                       OptionalAttr<ArrayAttr>:$constParams);
+  let arguments = (ins StrAttr:$name, Variadic<PDL_AnyType>:$args);
   let assemblyFormat = [{
-    $name ($constParams^)? `(` $args `:` type($args) `)` attr-dict `->`
-    successors
+    $name `(` $args `:` type($args) `)` attr-dict `->` successors
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::ApplyRewriteOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_ApplyRewriteOp : PDLInterp_Op<"apply_rewrite"> {
   let summary = "Invoke and apply an externally registered rewrite method";
   let description = [{
     `pdl_interp.apply_rewrite` operations invoke an external rewriter that has
     been registered with the interpreter to perform the rewrite after a
-    successful match. The rewrite is passed a set of positional arguments,
-    and a set of constant parameters. The rewrite function may return any
-    number of results.
+    successful match. The rewrite is passed a set of positional arguments. The
+    rewrite function may return any number of results.
 
     Example:
 
     ```mlir
     // Rewriter operating solely on the root operation.
     pdl_interp.apply_rewrite "rewriter"(%root : !pdl.operation)
 
     // Rewriter operating solely on the root operation and return an attribute.
     %attr = pdl_interp.apply_rewrite "rewriter"(%root : !pdl.operation) : !pdl.attribute
 
     // Rewriter operating on the root operation along with additional arguments
     // from the matcher.
     pdl_interp.apply_rewrite "rewriter"(%root : !pdl.operation, %value : !pdl.value)
-
-    // Rewriter operating on the root operation along with additional arguments
-    // and constant parameters.
-    pdl_interp.apply_rewrite "rewriter"[42](%root : !pdl.operation, %value : !pdl.value)
     ```
   }];
-  let arguments = (ins StrAttr:$name,
-                       Variadic<PDL_AnyType>:$args,
-                       OptionalAttr<ArrayAttr>:$constParams);
+  let arguments = (ins StrAttr:$name, Variadic<PDL_AnyType>:$args);
   let results = (outs Variadic<PDL_AnyType>:$results);
   let assemblyFormat = [{
-    $name ($constParams^)? (`(` $args^ `:` type($args) `)`)?
-    (`:` type($results)^)? attr-dict
+    $name (`(` $args^ `:` type($args) `)`)? (`:` type($results)^)? attr-dict
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::AreEqualOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_AreEqualOp

mlir/include/mlir/IR/PatternMatch.h

protected:
   SmallVector<llvm::OwningArrayRef<Type>> allocatedTypeRanges;
   SmallVector<llvm::OwningArrayRef<Value>> allocatedValueRanges;
 };
 
 //===----------------------------------------------------------------------===//
 // PDLPatternModule
 
 /// A generic PDL pattern constraint function. This function applies a
-/// constraint to a given set of opaque PDLValue entities. The second parameter
-/// is a set of constant value parameters specified in Attribute form. Returns
-/// success if the constraint successfully held, failure otherwise.
-using PDLConstraintFunction = std::function<LogicalResult(
-    ArrayRef<PDLValue>, ArrayAttr, PatternRewriter &)>;
-/// A native PDL rewrite function. This function performs a rewrite on the
-/// given set of values and constant parameters. Any results from this rewrite
-/// that should be passed back to PDL should be added to the provided result
-/// list. This method is only invoked when the corresponding match was
-/// successful.
-using PDLRewriteFunction = std::function<void(
-    ArrayRef<PDLValue>, ArrayAttr, PatternRewriter &, PDLResultList &)>;
-/// A generic PDL pattern constraint function. This function applies a
-/// constraint to a given opaque PDLValue entity. The second parameter is a set
-/// of constant value parameters specified in Attribute form. Returns success if
+/// constraint to a given set of opaque PDLValue entities. Returns success if
 /// the constraint successfully held, failure otherwise.
-using PDLSingleEntityConstraintFunction =
-    std::function<LogicalResult(PDLValue, ArrayAttr, PatternRewriter &)>;
+using PDLConstraintFunction =
+    std::function<LogicalResult(ArrayRef<PDLValue>, PatternRewriter &)>;
+/// A native PDL rewrite function. This function performs a rewrite on the
+/// given set of values. Any results from this rewrite that should be passed
+/// back to PDL should be added to the provided result list. This method is only
+/// invoked when the corresponding match was successful.
+using PDLRewriteFunction =
+    std::function<void(ArrayRef<PDLValue>, PatternRewriter &, PDLResultList &)>;
 
 /// This class contains all of the necessary data for a set of PDL patterns, or
 /// pattern rewrites specified in the form of the PDL dialect. This PDL module
 /// contained by this pattern may contain any number of `pdl.pattern`
 /// operations.
 class PDLPatternModule {
 public:
   PDLPatternModule() = default;
public:
   // Function Registry
 
   /// Register a constraint function.
   void registerConstraintFunction(StringRef name,
                                   PDLConstraintFunction constraintFn);
   /// Register a single entity constraint function.
   template <typename SingleEntityFn>
   std::enable_if_t<!llvm::is_invocable<SingleEntityFn, ArrayRef<PDLValue>,
-                                       ArrayAttr, PatternRewriter &>::value>
+                                       PatternRewriter &>::value>
   registerConstraintFunction(StringRef name, SingleEntityFn &&constraintFn) {
     registerConstraintFunction(
         name, [constraintFn = std::forward<SingleEntityFn>(constraintFn)](
-                  ArrayRef<PDLValue> values, ArrayAttr constantParams,
-                  PatternRewriter &rewriter) {
+                  ArrayRef<PDLValue> values, PatternRewriter &rewriter) {
           assert(values.size() == 1 &&
                  "expected values to have a single entity");
-          return constraintFn(values[0], constantParams, rewriter);
+          return constraintFn(values[0], rewriter);
         });
   }
 
   /// Register a rewrite function.
   void registerRewriteFunction(StringRef name, PDLRewriteFunction rewriteFn);
 
   /// Return the set of the registered constraint functions.
   const llvm::StringMap<PDLConstraintFunction> &getConstraintFunctions() const {

mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp

case Predicates::EqualToQuestion: {
     bool trueAnswer = isa<TrueAnswer>(answer);
     builder.create<pdl_interp::AreEqualOp>(loc, val, args.front(),
                                            trueAnswer ? success : failure,
                                            trueAnswer ? failure : success);
     break;
   }
   case Predicates::ConstraintQuestion: {
     auto *cstQuestion = cast<ConstraintQuestion>(question);
-    builder.create<pdl_interp::ApplyConstraintOp>(
-        loc, cstQuestion->getName(), args, cstQuestion->getParams(), success,
-        failure);
+    builder.create<pdl_interp::ApplyConstraintOp>(loc, cstQuestion->getName(),
+                                                  args, success, failure);
     break;
   }
   default:
     llvm_unreachable("Generating unknown Predicate operation");
   }
 }
 
 template <typename OpT, typename PredT, typename ValT = typename PredT::KeyTy>
SymbolRefAttr PatternLowering::generateRewriter(
   pdl::RewriteOp rewriter = pattern.getRewriter();
   if (StringAttr rewriteName = rewriter.nameAttr()) {
     SmallVector<Value> args;
     if (rewriter.root())
       args.push_back(mapRewriteValue(rewriter.root()));
     auto mappedArgs = llvm::map_range(rewriter.externalArgs(), mapRewriteValue);
     args.append(mappedArgs.begin(), mappedArgs.end());
     builder.create<pdl_interp::ApplyRewriteOp>(
-        rewriter.getLoc(), /*resultTypes=*/TypeRange(), rewriteName, args,
-        rewriter.externalConstParamsAttr());
+        rewriter.getLoc(), /*resultTypes=*/TypeRange(), rewriteName, args);
   } else {
     // Otherwise this is a dag rewriter defined using PDL operations.
     for (Operation &rewriteOp : *rewriter.getBody()) {
       llvm::TypeSwitch<Operation *>(&rewriteOp)
           .Case<pdl::ApplyNativeRewriteOp, pdl::AttributeOp, pdl::EraseOp,
                 pdl::OperationOp, pdl::ReplaceOp, pdl::ResultOp, pdl::ResultsOp,
                 pdl::TypeOp, pdl::TypesOp>([&](auto op) {
             this->generateRewriter(op, rewriteValues, mapRewriteValue);

 void PatternLowering::generateRewriter(
     pdl::ApplyNativeRewriteOp rewriteOp, DenseMap<Value, Value> &rewriteValues,
     function_ref<Value(Value)> mapRewriteValue) {
   SmallVector<Value, 2> arguments;
   for (Value argument : rewriteOp.args())
     arguments.push_back(mapRewriteValue(argument));
   auto interpOp = builder.create<pdl_interp::ApplyRewriteOp>(
       rewriteOp.getLoc(), rewriteOp.getResultTypes(), rewriteOp.nameAttr(),
-      arguments, rewriteOp.constParamsAttr());
-  for (auto it : llvm::zip(rewriteOp.results(), interpOp.getResults()))
+      arguments);
+  for (auto it : llvm::zip(rewriteOp.getResults(), interpOp.getResults()))
     rewriteValues[std::get<0>(it)] = std::get<1>(it);
 }
 
 void PatternLowering::generateRewriter(
     pdl::AttributeOp attrOp, DenseMap<Value, Value> &rewriteValues,
     function_ref<Value(Value)> mapRewriteValue) {
   Value newAttr = builder.create<pdl_interp::CreateAttributeOp>(
       attrOp.getLoc(), attrOp.valueAttr());

mlir/lib/Conversion/PDLToPDLInterp/Predicate.h

 
 /// Compare an `Attribute` to a constant value.
 struct AttributeQuestion
     : public PredicateBase<AttributeQuestion, Qualifier, void,
                            Predicates::AttributeQuestion> {};
 
 /// Apply a parameterized constraint to multiple position values.
 struct ConstraintQuestion
-    : public PredicateBase<
-          ConstraintQuestion, Qualifier,
-          std::tuple<StringRef, ArrayRef<Position *>, Attribute>,
+    : public PredicateBase<ConstraintQuestion, Qualifier,
+                           std::tuple<StringRef, ArrayRef<Position *>>,
                            Predicates::ConstraintQuestion> {
   using Base::Base;
 
   /// Return the name of the constraint.
   StringRef getName() const { return std::get<0>(key); }
 
   /// Return the arguments of the constraint.
   ArrayRef<Position *> getArgs() const { return std::get<1>(key); }
 
-  /// Return the constant parameters of the constraint.
-  ArrayAttr getParams() const {
-    return std::get<2>(key).dyn_cast_or_null<ArrayAttr>();
-  }
-
   /// Construct an instance with the given storage allocator.
   static ConstraintQuestion *construct(StorageUniquer::StorageAllocator &alloc,
                                        KeyTy key) {
     return Base::construct(alloc, KeyTy{alloc.copyInto(std::get<0>(key)),
-                                        alloc.copyInto(std::get<1>(key)),
-                                        std::get<2>(key)});
+                                        alloc.copyInto(std::get<1>(key))});
   }
 };
 
 /// Compare the equality of two values.
 struct EqualToQuestion
     : public PredicateBase<EqualToQuestion, Qualifier, Position *,
                            Predicates::EqualToQuestion> {
   using Base::Base;
public:
   }
 
   /// Create a predicate checking if two values are not equal.
   Predicate getNotEqualTo(Position *pos) {
     return {EqualToQuestion::get(uniquer, pos), FalseAnswer::get(uniquer)};
   }
 
   /// Create a predicate that applies a generic constraint.
-  Predicate getConstraint(StringRef name, ArrayRef<Position *> pos,
-                          Attribute params) {
-    return {
-        ConstraintQuestion::get(uniquer, std::make_tuple(name, pos, params)),
+  Predicate getConstraint(StringRef name, ArrayRef<Position *> pos) {
+    return {ConstraintQuestion::get(uniquer, std::make_tuple(name, pos)),
             TrueAnswer::get(uniquer)};
   }
 
   /// Create a predicate comparing a value with null.
   Predicate getIsNotNull() {
     return {IsNotNullQuestion::get(uniquer), TrueAnswer::get(uniquer)};
   }
 
   /// Create a predicate comparing the number of operands of an operation to a

mlir/lib/Conversion/PDLToPDLInterp/PredicateTree.cpp

static void getAttributePredicates(pdl::AttributeOp op,
   attrPos = builder.getAttributeLiteral(value);
 }
 
 static void getConstraintPredicates(pdl::ApplyNativeConstraintOp op,
                                     std::vector<PositionalPredicate> &predList,
                                     PredicateBuilder &builder,
                                     DenseMap<Value, Position *> &inputs) {
   OperandRange arguments = op.args();
-  ArrayAttr parameters = op.constParamsAttr();
 
   std::vector<Position *> allPositions;
   allPositions.reserve(arguments.size());
   for (Value arg : arguments)
     allPositions.push_back(inputs.lookup(arg));
 
   // Push the constraint to the furthest position.
   Position *pos = *std::max_element(allPositions.begin(), allPositions.end(),
                                     comparePosDepth);
   PredicateBuilder::Predicate pred =
-      builder.getConstraint(op.name(), allPositions, parameters);
+      builder.getConstraint(op.name(), allPositions);
   predList.emplace_back(pos, pred);
 }
 
 static void getResultPredicates(pdl::ResultOp op,
                                 std::vector<PositionalPredicate> &predList,
                                 PredicateBuilder &builder,
                                 DenseMap<Value, Position *> &inputs) {
   Position *&resultPos = inputs[op];

mlir/lib/Dialect/PDL/IR/PDL.cpp

return emitOpError() << "expected rewrite region to be non-empty if "
                             "external name is not specified";
   }
 
   // Check that no additional arguments were provided.
   if (!externalArgs().empty()) {
     return emitOpError() << "expected no external arguments when the "
                             "rewrite is specified inline";
   }
-  if (externalConstParams()) {
-    return emitOpError() << "expected no external constant parameters when "
-                            "the rewrite is specified inline";
-  }
 
   return success();
 }
 
 /// The default dialect is `pdl`.
 StringRef RewriteOp::getDefaultDialect() {
   return PDLDialect::getDialectNamespace();
 }

mlir/lib/Rewrite/ByteCode.cpp

TypeSwitch<Operation *>(op)
         llvm_unreachable("unknown `pdl_interp` operation");
       });
 }
 
 void Generator::generate(pdl_interp::ApplyConstraintOp op,
                          ByteCodeWriter &writer) {
   assert(constraintToMemIndex.count(op.getName()) &&
          "expected index for constraint function");
-  writer.append(OpCode::ApplyConstraint, constraintToMemIndex[op.getName()],
-                op.getConstParamsAttr());
+  writer.append(OpCode::ApplyConstraint, constraintToMemIndex[op.getName()]);
   writer.appendPDLValueList(op.getArgs());
   writer.append(op.getSuccessors());
 }
 void Generator::generate(pdl_interp::ApplyRewriteOp op,
                          ByteCodeWriter &writer) {
   assert(externalRewriterToMemIndex.count(op.getName()) &&
          "expected index for rewrite function");
-  writer.append(OpCode::ApplyRewrite, externalRewriterToMemIndex[op.getName()],
-                op.getConstParamsAttr());
+  writer.append(OpCode::ApplyRewrite, externalRewriterToMemIndex[op.getName()]);
   writer.appendPDLValueList(op.getArgs());
 
   ResultRange results = op.getResults();
   writer.append(ByteCodeField(results.size()));
   for (Value result : results) {
     // In debug mode we also record the expected kind of the result, so that we
     // can provide extra verification of the native rewrite function.
 #ifndef NDEBUG
MutableArrayRef<llvm::OwningArrayRef<Value>> getAllocatedValueRanges() {
     return allocatedValueRanges;
   }
 };
 } // namespace
 
 void ByteCodeExecutor::executeApplyConstraint(PatternRewriter &rewriter) {
   LLVM_DEBUG(llvm::dbgs() << "Executing ApplyConstraint:\n");
   const PDLConstraintFunction &constraintFn = constraintFunctions[read()];
-  ArrayAttr constParams = read<ArrayAttr>();
   SmallVector<PDLValue, 16> args;
   readList<PDLValue>(args);
 
   LLVM_DEBUG({
     llvm::dbgs() << "  * Arguments: ";
     llvm::interleaveComma(args, llvm::dbgs());
-    llvm::dbgs() << "\n  * Parameters: " << constParams << "\n";
   });
 
   // Invoke the constraint and jump to the proper destination.
-  selectJump(succeeded(constraintFn(args, constParams, rewriter)));
+  selectJump(succeeded(constraintFn(args, rewriter)));
 }
 
 void ByteCodeExecutor::executeApplyRewrite(PatternRewriter &rewriter) {
   LLVM_DEBUG(llvm::dbgs() << "Executing ApplyRewrite:\n");
   const PDLRewriteFunction &rewriteFn = rewriteFunctions[read()];
-  ArrayAttr constParams = read<ArrayAttr>();
   SmallVector<PDLValue, 16> args;
   readList<PDLValue>(args);
 
   LLVM_DEBUG({
     llvm::dbgs() << "  * Arguments: ";
     llvm::interleaveComma(args, llvm::dbgs());
-    llvm::dbgs() << "\n  * Parameters: " << constParams << "\n";
   });
 
   // Execute the rewrite function.
   ByteCodeField numResults = read();
   ByteCodeRewriteResultList results(numResults);
-  rewriteFn(args, constParams, rewriter, results);
+  rewriteFn(args, rewriter, results);
 
   assert(results.getResults().size() == numResults &&
          "native PDL rewrite function returned unexpected number of results");
 
   // Store the results in the bytecode memory.
   for (PDLValue &result : results.getResults()) {
     LLVM_DEBUG(llvm::dbgs() << "  * Result: " << result << "\n");
 

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

void CodeGen::generateConstraintOrRewrite(StringRef name, bool isConstraint,
   };
 
   // FIXME: We currently do not have a modeling for the "constant params"
   // support PDL provides. We should either figure out a modeling for this, or
   // refactor the support within PDL to be something a bit more reasonable for
   // what we need as a frontend.
   os << "static " << (isConstraint ? "::mlir::LogicalResult " : "void ") << name
      << "PDLFn(::llvm::ArrayRef<::mlir::PDLValue> values, "
-        "::mlir::ArrayAttr constParams, ::mlir::PatternRewriter &rewriter"
+        "::mlir::PatternRewriter &rewriter"
      << (isConstraint ? "" : ", ::mlir::PDLResultList &results") << ") {\n";
 
   const char *argumentInitStr = R"(
   {0} {1} = {{};
   if (values[{2}])
     {1} = values[{2}].cast<{0}>();
   (void){1};
 )";

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

 }
 
 /// If the given builder is nested under a PDL PatternOp, build a rewrite
 /// operation and update the builder to nest under it. This is necessary for
 /// PDLL operation rewrite statements that are directly nested within a Pattern.
 static void checkAndNestUnderRewriteOp(OpBuilder &builder, Value rootExpr,
                                        Location loc) {
   if (isa<pdl::PatternOp>(builder.getInsertionBlock()->getParentOp())) {
-    pdl::RewriteOp rewrite = builder.create<pdl::RewriteOp>(
-        loc, rootExpr, /*name=*/StringAttr(),
-        /*externalArgs=*/ValueRange(), /*externalConstParams=*/ArrayAttr());
+    pdl::RewriteOp rewrite =
+        builder.create<pdl::RewriteOp>(loc, rootExpr, /*name=*/StringAttr(),
+                                       /*externalArgs=*/ValueRange());
     builder.createBlock(&rewrite.body());
   }
 }
 
 void CodeGen::genImpl(const ast::EraseStmt *stmt) {
   OpBuilder::InsertionGuard insertGuard(builder);
   Value rootExpr = genSingleExpr(stmt->getRootOpExpr());
   Location loc = genLoc(stmt->getLoc());
if (!cstBody) {
     ast::Type declResultType = decl->getResultType();
     SmallVector<Type> resultTypes;
     if (ast::TupleType tupleType = declResultType.dyn_cast<ast::TupleType>()) {
       for (ast::Type type : tupleType.getElementTypes())
         resultTypes.push_back(genType(type));
     } else {
       resultTypes.push_back(genType(declResultType));
     }
-
-    // FIXME: We currently do not have a modeling for the "constant params"
-    // support PDL provides. We should either figure out a modeling for this, or
-    // refactor the support within PDL to be something a bit more reasonable for
-    // what we need as a frontend.
-    Operation *pdlOp = builder.create<PDLOpT>(loc, resultTypes,
-                                              decl->getName().getName(), inputs,
-                                              /*params=*/ArrayAttr());
+    Operation *pdlOp = builder.create<PDLOpT>(
+        loc, resultTypes, decl->getName().getName(), inputs);
     return pdlOp->getResults();
   }
 
   // Otherwise, this is a PDLL decl.
   VariableMapTy::ScopeTy varScope(variables);
 
   // Map the inputs of the call to the decl arguments.
   // Note: This is only valid because we do not support recursion, meaning

mlir/python/mlir/dialects/_pdl_ops_ext.py

 
 
 class ApplyNativeConstraintOp:
   """Specialization for PDL apply native constraint op class."""
 
   def __init__(self,
                name: Union[str, StringAttr],
                args: Sequence[Union[OpView, Operation, Value]] = [],
-               params: Optional[Union[ArrayAttr, Sequence[Attribute]]] = None,
                *,
                loc=None,
                ip=None):
     name = _get_str_attr(name)
     args = _get_values(args)
-    params = params if params is None else _get_array_attr(params)
-    super().__init__(name, args, params, loc=loc, ip=ip)
+    super().__init__(name, args, loc=loc, ip=ip)
 
 
 class ApplyNativeRewriteOp:
   """Specialization for PDL apply native rewrite op class."""
 
   def __init__(self,
                results: Sequence[Type],
                name: Union[str, StringAttr],
                args: Sequence[Union[OpView, Operation, Value]] = [],
-               params: Optional[Union[ArrayAttr, Sequence[Attribute]]] = None,
                *,
                loc=None,
                ip=None):
     name = _get_str_attr(name)
     args = _get_values(args)
-    params = params if params is None else _get_array_attr(params)
-    super().__init__(results, name, args, params, loc=loc, ip=ip)
+    super().__init__(results, name, args, loc=loc, ip=ip)
 
 
 class AttributeOp:
   """Specialization for PDL attribute op class."""
 
   def __init__(self,
                type: Optional[Union[OpView, Operation, Value]] = None,
                value: Optional[Attribute] = None,

 
 class RewriteOp:
   """Specialization for PDL rewrite op class."""
 
   def __init__(self,
                root: Optional[Union[OpView, Operation, Value]] = None,
                name: Optional[Union[StringAttr, str]] = None,
                args: Sequence[Union[OpView, Operation, Value]] = [],
-               params: Optional[Union[ArrayAttr, Sequence[Attribute]]] = None,
                *,
                loc=None,
                ip=None):
     root = root if root is None else _get_value(root)
     name = name if name is None else _get_str_attr(name)
     args = _get_values(args)
-    params = params if params is None else _get_array_attr(params)
-    super().__init__(root, name, args, params, loc=loc, ip=ip)
+    super().__init__(root, name, args, loc=loc, ip=ip)
 
   def add_body(self):
     """Add body (block) to the rewrite."""
     self.regions[0].blocks.append()
     return self.body
 
   @property
   def body(self):

mlir/test/Conversion/PDLToPDLInterp/pdl-to-pdl-interp-matcher.mlir

 // -----
 
 // CHECK-LABEL: module @constraints
 module @constraints {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK-DAG:   %[[INPUT:.*]] = pdl_interp.get_operand 0 of %[[ROOT]]
   // CHECK-DAG:   %[[INPUT1:.*]] = pdl_interp.get_operand 1 of %[[ROOT]]
   // CHECK-DAG:   %[[RESULT:.*]] = pdl_interp.get_result 0 of %[[ROOT]]
-  // CHECK:       pdl_interp.apply_constraint "multi_constraint" [true](%[[INPUT]], %[[INPUT1]], %[[RESULT]]
+  // CHECK:       pdl_interp.apply_constraint "multi_constraint"(%[[INPUT]], %[[INPUT1]], %[[RESULT]]
 
   pdl.pattern : benefit(1) {
     %input0 = operand
     %input1 = operand
     %root = operation(%input0, %input1 : !pdl.value, !pdl.value)
     %result0 = result 0 of %root
 
-    pdl.apply_native_constraint "multi_constraint"[true](%input0, %input1, %result0 : !pdl.value, !pdl.value, !pdl.value)
+    pdl.apply_native_constraint "multi_constraint"(%input0, %input1, %result0 : !pdl.value, !pdl.value, !pdl.value)
     rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @inputs
 module @inputs {
module @predicate_ordering {
   // Check that the result is checked for null first, before applying the
   // constraint. The null check is prevalent in both patterns, so should be
   // prioritized first.
 
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:   %[[RESULT:.*]] = pdl_interp.get_result 0 of %[[ROOT]]
   // CHECK-NEXT: pdl_interp.is_not_null %[[RESULT]]
   // CHECK:   %[[RESULT_TYPE:.*]] = pdl_interp.get_value_type of %[[RESULT]]
-  // CHECK: pdl_interp.apply_constraint "typeConstraint" [](%[[RESULT_TYPE]]
+  // CHECK: pdl_interp.apply_constraint "typeConstraint"(%[[RESULT_TYPE]]
 
   pdl.pattern : benefit(1) {
     %resultType = type
-    pdl.apply_native_constraint "typeConstraint"[](%resultType : !pdl.type)
+    pdl.apply_native_constraint "typeConstraint"(%resultType : !pdl.type)
     %root = operation -> (%resultType : !pdl.type)
     rewrite %root with "rewriter"
   }
 
   pdl.pattern : benefit(1) {
     %resultType = type
     %apply = operation -> (%resultType : !pdl.type)
     rewrite %apply with "rewriter"

mlir/test/Conversion/PDLToPDLInterp/pdl-to-pdl-interp-rewriter.mlir

 // RUN: mlir-opt -split-input-file -convert-pdl-to-pdl-interp %s | FileCheck %s
 
 // -----
 
 // CHECK-LABEL: module @external
 module @external {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation, %[[INPUT:.*]]: !pdl.value)
-  // CHECK:     pdl_interp.apply_rewrite "rewriter" [true](%[[ROOT]], %[[INPUT]] : !pdl.operation, !pdl.value)
+  // CHECK:     pdl_interp.apply_rewrite "rewriter"(%[[ROOT]], %[[INPUT]] : !pdl.operation, !pdl.value)
   pdl.pattern : benefit(1) {
     %input = operand
     %root = operation "foo.op"(%input : !pdl.value)
-    rewrite %root with "rewriter"[true](%input : !pdl.value)
+    rewrite %root with "rewriter"(%input : !pdl.value)
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @erase
 module @erase {
   // CHECK: module @rewriters

 }
 
 // -----
 
 // CHECK-LABEL: module @apply_native_rewrite
 module @apply_native_rewrite {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation)
-  // CHECK:     %[[TYPE:.*]] = pdl_interp.apply_rewrite "functor" [true](%[[ROOT]] : !pdl.operation) : !pdl.type
+  // CHECK:     %[[TYPE:.*]] = pdl_interp.apply_rewrite "functor"(%[[ROOT]] : !pdl.operation) : !pdl.type
   // CHECK:     pdl_interp.create_operation "foo.op" -> (%[[TYPE]] : !pdl.type)
   pdl.pattern : benefit(1) {
     %type = type
     %root = operation "foo.op" -> (%type : !pdl.type)
     rewrite %root {
-      %newType = apply_native_rewrite "functor"[true](%root : !pdl.operation) : !pdl.type
+      %newType = apply_native_rewrite "functor"(%root : !pdl.operation) : !pdl.type
       %newOp = operation "foo.op" -> (%newType : !pdl.type)
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @unbound_rewrite_op

mlir/test/Dialect/PDL/invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 //===----------------------------------------------------------------------===//
 // pdl::ApplyNativeConstraintOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   %op = operation "foo.op"
 
   // expected-error@below {{expected at least one argument}}
-  "pdl.apply_native_constraint"() {name = "foo", params = []} : () -> ()
+  "pdl.apply_native_constraint"() {name = "foo"} : () -> ()
   rewrite %op with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::ApplyNativeRewriteOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   %op = operation "foo.op"
   rewrite %op {
     // expected-error@below {{expected at least one argument}}
-    "pdl.apply_native_rewrite"() {name = "foo", params = []} : () -> ()
+    "pdl.apply_native_rewrite"() {name = "foo"} : () -> ()
   }
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::AttributeOp
 //===----------------------------------------------------------------------===//
pdl.pattern : benefit(1) {
   }: (!pdl.operation, !pdl.operation) -> ()
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
   %op = operation "foo.op"
 
-  // expected-error@below {{expected no external constant parameters when the rewrite is specified inline}}
-  "pdl.rewrite"(%op) ({
-    ^bb1:
-  }) {
-    operand_segment_sizes = dense<[1,0]> : vector<2xi32>,
-    externalConstParams = []} : (!pdl.operation) -> ()
-}
-
-// -----
-
-pdl.pattern : benefit(1) {
-  %op = operation "foo.op"
-
   // expected-error@below {{expected rewrite region to be empty when rewrite is external}}
   "pdl.rewrite"(%op) ({
     ^bb1:
   }) {
     name = "foo",
     operand_segment_sizes = dense<[1,0]> : vector<2xi32>
   } : (!pdl.operation) -> ()
 }

mlir/test/Dialect/PDL/ops.mlir

 pdl.pattern @rewrite_with_args : benefit(1) {
   %input = operand
   %root = operation(%input : !pdl.value)
   rewrite %root with "rewriter"(%input : !pdl.value)
 }
 
 // -----
 
-pdl.pattern @rewrite_with_params : benefit(1) {
-  %root = operation
-  rewrite %root with "rewriter"["I am param"]
-}
-
-// -----
-
-pdl.pattern @rewrite_with_args_and_params : benefit(1) {
-  %input = operand
-  %root = operation(%input : !pdl.value)
-  rewrite %root with "rewriter"["I am param"](%input : !pdl.value)
-}
-
-// -----
-
 pdl.pattern @rewrite_multi_root_optimal : benefit(2) {
   %input1 = operand
   %input2 = operand
   %type = type
   %op1 = operation(%input1 : !pdl.value) -> (%type : !pdl.type)
   %val1 = result 0 of %op1
   %root1 = operation(%val1 : !pdl.value)
   %op2 = operation(%input2 : !pdl.value) -> (%type : !pdl.type)
   %val2 = result 0 of %op2
   %root2 = operation(%val1, %val2 : !pdl.value, !pdl.value)
-  rewrite with "rewriter"["I am param"](%root1, %root2 : !pdl.operation, !pdl.operation)
+  rewrite with "rewriter"(%root1, %root2 : !pdl.operation, !pdl.operation)
 }
 
 // -----
 
 pdl.pattern @rewrite_multi_root_forced : benefit(2) {
   %input1 = operand
   %input2 = operand
   %type = type
   %op1 = operation(%input1 : !pdl.value) -> (%type : !pdl.type)
   %val1 = result 0 of %op1
   %root1 = operation(%val1 : !pdl.value)
   %op2 = operation(%input2 : !pdl.value) -> (%type : !pdl.type)
   %val2 = result 0 of %op2
   %root2 = operation(%val1, %val2 : !pdl.value, !pdl.value)
-  rewrite %root1 with "rewriter"["I am param"](%root2 : !pdl.operation)
+  rewrite %root1 with "rewriter"(%root2 : !pdl.operation)
 }
 
 // -----
 
 // Check that the result type of an operation within a rewrite can be inferred
 // from a pdl.replace.
 pdl.pattern @infer_type_from_operation_replace : benefit(1) {
   %type1 = type : i32

mlir/test/Rewrite/pdl-bytecode.mlir

module @patterns {
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
     pdl_interp.func @success(%root : !pdl.operation) {
       %operand = pdl_interp.get_operand 0 of %root
-      pdl_interp.apply_rewrite "rewriter"[42](%root, %operand : !pdl.operation, !pdl.value)
+      pdl_interp.apply_rewrite "rewriter"(%root, %operand : !pdl.operation, !pdl.value)
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.apply_rewrite_1
 // CHECK: %[[INPUT:.*]] = "test.op_input"
 // CHECK-NOT: "test.op"
-// CHECK: "test.success"(%[[INPUT]]) {constantParams = [42]}
+// CHECK: "test.success"(%[[INPUT]])
 module @ir attributes { test.apply_rewrite_1 } {
   %input = "test.op_input"() : () -> i32
   "test.op"(%input) : (i32) -> ()
 }
 
 // -----
 
 module @patterns {

mlir/test/lib/Rewrite/TestPDLByteCode.cpp

 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 /// Custom constraint invoked from PDL.
 static LogicalResult customSingleEntityConstraint(PDLValue value,
-                                                  ArrayAttr constantParams,
                                                   PatternRewriter &rewriter) {
   Operation *rootOp = value.cast<Operation *>();
   return success(rootOp->getName().getStringRef() == "test.op");
 }
 static LogicalResult customMultiEntityConstraint(ArrayRef<PDLValue> values,
-                                                 ArrayAttr constantParams,
                                                  PatternRewriter &rewriter) {
-  return customSingleEntityConstraint(values[1], constantParams, rewriter);
+  return customSingleEntityConstraint(values[1], rewriter);
 }
 static LogicalResult
 customMultiEntityVariadicConstraint(ArrayRef<PDLValue> values,
-                                    ArrayAttr constantParams,
                                     PatternRewriter &rewriter) {
   if (llvm::any_of(values, [](const PDLValue &value) { return !value; }))
     return failure();
   ValueRange operandValues = values[0].cast<ValueRange>();
   TypeRange typeValues = values[1].cast<TypeRange>();
   if (operandValues.size() != 2 || typeValues.size() != 2)
     return failure();
   return success();
 }
 
 // Custom creator invoked from PDL.
-static void customCreate(ArrayRef<PDLValue> args, ArrayAttr constantParams,
-                         PatternRewriter &rewriter, PDLResultList &results) {
+static void customCreate(ArrayRef<PDLValue> args, PatternRewriter &rewriter,
+                         PDLResultList &results) {
   results.push_back(rewriter.createOperation(
       OperationState(args[0].cast<Operation *>()->getLoc(), "test.success")));
 }
 static void customVariadicResultCreate(ArrayRef<PDLValue> args,
-                                       ArrayAttr constantParams,
                                        PatternRewriter &rewriter,
                                        PDLResultList &results) {
   Operation *root = args[0].cast<Operation *>();
   results.push_back(root->getOperands());
   results.push_back(root->getOperands().getTypes());
 }
-static void customCreateType(ArrayRef<PDLValue> args, ArrayAttr constantParams,
-                             PatternRewriter &rewriter,
+static void customCreateType(ArrayRef<PDLValue> args, PatternRewriter &rewriter,
                              PDLResultList &results) {
   results.push_back(rewriter.getF32Type());
 }
 
 /// Custom rewriter invoked from PDL.
-static void customRewriter(ArrayRef<PDLValue> args, ArrayAttr constantParams,
-                           PatternRewriter &rewriter, PDLResultList &results) {
+static void customRewriter(ArrayRef<PDLValue> args, PatternRewriter &rewriter,
+                           PDLResultList &results) {
   Operation *root = args[0].cast<Operation *>();
   OperationState successOpState(root->getLoc(), "test.success");
   successOpState.addOperands(args[1].cast<Value>());
-  successOpState.addAttribute("constantParams", constantParams);
   rewriter.createOperation(successOpState);
   rewriter.eraseOp(root);
 }
 
 namespace {
 struct TestPDLByteCodePass
     : public PassWrapper<TestPDLByteCodePass, OperationPass<ModuleOp>> {
   StringRef getArgument() const final { return "test-pdl-bytecode-pass"; }

mlir/test/mlir-pdll/CodeGen/CPP/general.pdll

 Pattern NamedPattern => erase op<test.op2>;
 Pattern GeneratedPDLLPattern1 => erase op<>;
 Pattern => erase op<test.op3>;
 
 // -----
 
 // Check the generation of native constraints and rewrites.
 
-// CHECK:      static ::mlir::LogicalResult TestCstPDLFn(::llvm::ArrayRef<::mlir::PDLValue> values, ::mlir::ArrayAttr constParams,
+// CHECK:      static ::mlir::LogicalResult TestCstPDLFn(::llvm::ArrayRef<::mlir::PDLValue> values,
 // CHECK-SAME:                                           ::mlir::PatternRewriter &rewriter) {
 // CHECK:   ::mlir::Attribute attr = {};
 // CHECK:   if (values[0])
 // CHECK:     attr = values[0].cast<::mlir::Attribute>();
 // CHECK:   ::mlir::Operation * op = {};
 // CHECK:   if (values[1])
 // CHECK:     op = values[1].cast<::mlir::Operation *>();
 // CHECK:   ::mlir::Type type = {};

 // CHECK:   if (values[5])
 // CHECK:     valueRange = values[5].cast<::mlir::ValueRange>();
 
 // CHECK:   return success();
 // CHECK: }
 
 // CHECK-NOT: TestUnusedCst
 
-// CHECK: static void TestRewritePDLFn(::llvm::ArrayRef<::mlir::PDLValue> values, ::mlir::ArrayAttr constParams,
+// CHECK: static void TestRewritePDLFn(::llvm::ArrayRef<::mlir::PDLValue> values,
 // CHECK-SAME:                         ::mlir::PatternRewriter &rewriter, ::mlir::PDLResultList &results) {
 // CHECK:   ::mlir::Attribute attr = {};
 // CHECK:   ::mlir::Operation * op = {};
 // CHECK:   ::mlir::Type type = {};
 // CHECK:   ::mlir::Value value = {};
 // CHECK:   ::mlir::TypeRange typeRange = {};
 // CHECK:   ::mlir::ValueRange valueRange = {};
 

mlir/test/python/dialects/pdl_ops.py

 def test_rewrite_with_args():
   pattern = PatternOp(1, "rewrite_with_args")
   with InsertionPoint(pattern.body):
     input = OperandOp()
     root = OperationOp(args=[input])
     RewriteOp(root, "rewriter", args=[input])
 
 # CHECK: module  {
-# CHECK:   pdl.pattern @rewrite_with_params : benefit(1)  {
-# CHECK:     %0 = operation
-# CHECK:     rewrite %0 with "rewriter" ["I am param"]
-# CHECK:   }
-# CHECK: }
-@constructAndPrintInModule
-def test_rewrite_with_params():
-  pattern = PatternOp(1, "rewrite_with_params")
-  with InsertionPoint(pattern.body):
-    op = OperationOp()
-    RewriteOp(op, "rewriter", params=[StringAttr.get("I am param")])
-
-# CHECK: module  {
-# CHECK:   pdl.pattern @rewrite_with_args_and_params : benefit(1)  {
-# CHECK:     %0 = operand
-# CHECK:     %1 = operation(%0 : !pdl.value)
-# CHECK:     rewrite %1 with "rewriter" ["I am param"](%0 : !pdl.value)
-# CHECK:   }
-# CHECK: }
-@constructAndPrintInModule
-def test_rewrite_with_args_and_params():
-  pattern = PatternOp(1, "rewrite_with_args_and_params")
-  with InsertionPoint(pattern.body):
-    input = OperandOp()
-    root = OperationOp(args=[input])
-    RewriteOp(root, "rewriter", params=[StringAttr.get("I am param")], args=[input])
-
-# CHECK: module  {
 # CHECK:   pdl.pattern @rewrite_multi_root_optimal : benefit(1)  {
 # CHECK:     %0 = operand
 # CHECK:     %1 = operand
 # CHECK:     %2 = type
 # CHECK:     %3 = operation(%0 : !pdl.value)  -> (%2 : !pdl.type)
 # CHECK:     %4 = result 0 of %3
 # CHECK:     %5 = operation(%4 : !pdl.value)
 # CHECK:     %6 = operation(%1 : !pdl.value)  -> (%2 : !pdl.type)
 # CHECK:     %7 = result 0 of %6
 # CHECK:     %8 = operation(%4, %7 : !pdl.value, !pdl.value)
-# CHECK:     rewrite with "rewriter" ["I am param"](%5, %8 : !pdl.operation, !pdl.operation)
+# CHECK:     rewrite with "rewriter"(%5, %8 : !pdl.operation, !pdl.operation)
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_rewrite_multi_root_optimal():
   pattern = PatternOp(1, "rewrite_multi_root_optimal")
   with InsertionPoint(pattern.body):
     input1 = OperandOp()
     input2 = OperandOp()
     ty = TypeOp()
     op1 = OperationOp(args=[input1], types=[ty])
     val1 = ResultOp(op1, 0)
     root1 = OperationOp(args=[val1])
     op2 = OperationOp(args=[input2], types=[ty])
     val2 = ResultOp(op2, 0)
     root2 = OperationOp(args=[val1, val2])
-    RewriteOp(name="rewriter", params=[StringAttr.get("I am param")], args=[root1, root2])
+    RewriteOp(name="rewriter", args=[root1, root2])
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @rewrite_multi_root_forced : benefit(1)  {
 # CHECK:     %0 = operand
 # CHECK:     %1 = operand
 # CHECK:     %2 = type
 # CHECK:     %3 = operation(%0 : !pdl.value)  -> (%2 : !pdl.type)
 # CHECK:     %4 = result 0 of %3
 # CHECK:     %5 = operation(%4 : !pdl.value)
 # CHECK:     %6 = operation(%1 : !pdl.value)  -> (%2 : !pdl.type)
 # CHECK:     %7 = result 0 of %6
 # CHECK:     %8 = operation(%4, %7 : !pdl.value, !pdl.value)
-# CHECK:     rewrite %5 with "rewriter" ["I am param"](%8 : !pdl.operation)
+# CHECK:     rewrite %5 with "rewriter"(%8 : !pdl.operation)
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_rewrite_multi_root_forced():
   pattern = PatternOp(1, "rewrite_multi_root_forced")
   with InsertionPoint(pattern.body):
     input1 = OperandOp()
     input2 = OperandOp()
     ty = TypeOp()
     op1 = OperationOp(args=[input1], types=[ty])
     val1 = ResultOp(op1, 0)
     root1 = OperationOp(args=[val1])
     op2 = OperationOp(args=[input2], types=[ty])
     val2 = ResultOp(op2, 0)
     root2 = OperationOp(args=[val1, val2])
-    RewriteOp(root1, name="rewriter", params=[StringAttr.get("I am param")], args=[root2])
+    RewriteOp(root1, name="rewriter", args=[root2])
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @rewrite_add_body : benefit(1)  {
 # CHECK:     %0 = type : i32
 # CHECK:     %1 = type
 # CHECK:     %2 = operation  -> (%0, %1 : !pdl.type, !pdl.type)
 # CHECK:     rewrite %2  {
 # CHECK:       %3 = type
with InsertionPoint(pattern.body):
     inputOp = OperationOp(types=[types])
     results = ResultsOp(valueRange, inputOp)
     root = OperationOp(args=[results])
     RewriteOp(root, name="rewriter")
 
 # CHECK: module  {
 # CHECK:   pdl.pattern : benefit(1)  {
 # CHECK:     %0 = type
-# CHECK:     apply_native_constraint "typeConstraint" [](%0 : !pdl.type)
+# CHECK:     apply_native_constraint "typeConstraint"(%0 : !pdl.type)
 # CHECK:     %1 = operation  -> (%0 : !pdl.type)
 # CHECK:     rewrite %1 with "rewrite"
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_apply_native_constraint():
   pattern = PatternOp(1)
   with InsertionPoint(pattern.body):
     resultType = TypeOp()
-    ApplyNativeConstraintOp("typeConstraint", args=[resultType], params=[])
+    ApplyNativeConstraintOp("typeConstraint", args=[resultType])
     root = OperationOp(types=[resultType])
     RewriteOp(root, name="rewrite")