[mlir][PDL] Move the formats for PatternOp and RewriteOp to the declarative form.

[rriddle]

Summary

This is possible now that the declarative assembly form supports regions.

Depends On D86760

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

let description = [{
 
     ```mlir
     // Provide a pattern matching "foo.op" that replaces the root with its
     // input.
     pdl.pattern : benefit(1) {
       %resultType = pdl.type
       %inputOperand = pdl.input
       %root, %results = pdl.operation "foo.op"(%inputOperand) -> (%resultType)
-      pdl.rewrite(%root) {
+      pdl.rewrite %root {
         pdl.replace %root with (%inputOperand)
       }
     }
     ```
   }];
 
   let arguments = (ins OptionalAttr<StrAttr>:$rootKind,
                        Confined<I16Attr, [IntNonNegative]>:$benefit,
-                       OptionalAttr<StrAttr>:$sym_name);
-
+                       OptionalAttr<SymbolNameAttr>:$sym_name);
   let regions = (region SizedRegion<1>:$body);
+  let assemblyFormat = [{
+    ($sym_name^)? `:` `benefit` `(` $benefit `)`
+    (`,` `root` `(` $rootKind^ `)`)? attr-dict-with-keyword $body
+  }];
+
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &state, "
               "Optional<StringRef> rootKind = llvm::None, "
               "Optional<uint16_t> benefit = 1, "
               "Optional<StringRef> name = llvm::None">,
   ];
   let extraClassDeclaration = [{
     //===------------------------------------------------------------------===//
let description = [{
     ```
   }];
 
   let arguments = (ins PDL_Operation:$root,
                        OptionalAttr<StrAttr>:$name,
                        Variadic<PDL_PositionalValue>:$externalArgs,
                        OptionalAttr<ArrayAttr>:$externalConstParams);
   let regions = (region AnyRegion:$body);
+  let assemblyFormat = [{
+    $root (`with` $name^ ($externalConstParams^)?
+                         (`(` $externalArgs^ `:` type($externalArgs) `)`)?)?
+          ($body^)?
+    attr-dict-with-keyword
+  }];
 }
 
 def PDL_RewriteEndOp : PDL_Op<"rewrite_end", [Terminator,
                                               HasParent<"pdl::RewriteOp">]> {
   let summary = "Implicit terminator of a `pdl.rewrite` region";
   let description = [{
     `pdl.rewrite_end` operations terminate the region of a `pdl.rewrite`.
   }];

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

if (const AbstractOperation *op = name.getAbstractOperation())
     return op->getInterface<InferTypeOpInterface>();
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::PatternOp
 //===----------------------------------------------------------------------===//
 
-static ParseResult parsePatternOp(OpAsmParser &p, OperationState &state) {
-  StringAttr name;
-  p.parseOptionalSymbolName(name, SymbolTable::getSymbolAttrName(),
-                            state.attributes);
-
-  // Parse the benefit.
-  IntegerAttr benefitAttr;
-  if (p.parseColon() || p.parseKeyword("benefit") || p.parseLParen() ||
-      p.parseAttribute(benefitAttr, p.getBuilder().getIntegerType(16),
-                       "benefit", state.attributes) ||
-      p.parseRParen())
-    return failure();
-
-  // Parse the pattern body.
-  if (p.parseOptionalAttrDictWithKeyword(state.attributes) ||
-      p.parseRegion(*state.addRegion(), None, None))
-    return failure();
-  return success();
-}
-
-static void print(OpAsmPrinter &p, PatternOp op) {
-  p << "pdl.pattern";
-  if (Optional<StringRef> name = op.sym_name()) {
-    p << ' ';
-    p.printSymbolName(*name);
-  }
-  p << " : benefit(";
-  p.printAttributeWithoutType(op.benefitAttr());
-  p << ")";
-
-  p.printOptionalAttrDictWithKeyword(
-      op.getAttrs(), {"benefit", "rootKind", SymbolTable::getSymbolAttrName()});
-  p.printRegion(op.body());
-}
-
 static LogicalResult verify(PatternOp pattern) {
   Region &body = pattern.body();
   auto *term = body.front().getTerminator();
   if (!isa<RewriteOp>(term)) {
     return pattern.emitOpError("expected body to terminate with `pdl.rewrite`")
         .attachNote(term->getLoc())
         .append("see terminator defined here");
   }
static LogicalResult verify(ReplaceOp op) {
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::RewriteOp
 //===----------------------------------------------------------------------===//
 
-static ParseResult parseRewriteOp(OpAsmParser &p, OperationState &state) {
-  // Parse the root operand.
-  OpAsmParser::OperandType rootOperand;
-  if (p.parseOperand(rootOperand) ||
-      p.resolveOperand(rootOperand, p.getBuilder().getType<OperationType>(),
-                       state.operands))
-    return failure();
-
-  // Parse an external rewrite.
-  StringAttr nameAttr;
-  if (succeeded(p.parseOptionalKeyword("with"))) {
-    if (p.parseAttribute(nameAttr, "name", state.attributes))
-      return failure();
-
-    // Parse the optional set of constant parameters.
-    ArrayAttr constantParams;
-    OptionalParseResult constantParamResult = p.parseOptionalAttribute(
-        constantParams, "externalConstParams", state.attributes);
-    if (constantParamResult.hasValue() && failed(*constantParamResult))
-      return failure();
-
-    // Parse the optional additional arguments.
-    if (succeeded(p.parseOptionalLParen())) {
-      SmallVector<OpAsmParser::OperandType, 4> arguments;
-      SmallVector<Type, 4> argumentTypes;
-      llvm::SMLoc argumentLoc = p.getCurrentLocation();
-      if (p.parseOperandList(arguments) ||
-          p.parseColonTypeList(argumentTypes) || p.parseRParen() ||
-          p.resolveOperands(arguments, argumentTypes, argumentLoc,
-                            state.operands))
-        return failure();
-    }
-  }
-
-  // If this isn't an external rewrite, parse the region body.
-  Region &rewriteRegion = *state.addRegion();
-  if (!nameAttr) {
-    if (p.parseRegion(rewriteRegion, /*arguments=*/llvm::None,
-                      /*argTypes=*/llvm::None))
-      return failure();
-    RewriteOp::ensureTerminator(rewriteRegion, p.getBuilder(), state.location);
-  }
-
-  return p.parseOptionalAttrDictWithKeyword(state.attributes);
-}
-
-static void print(OpAsmPrinter &p, RewriteOp op) {
-  p << "pdl.rewrite " << op.root();
-  if (Optional<StringRef> name = op.name()) {
-    p << " with \"" << *name << "\"";
-
-    if (ArrayAttr constantParams = op.externalConstParamsAttr())
-      p << constantParams;
-
-    OperandRange externalArgs = op.externalArgs();
-    if (!externalArgs.empty())
-      p << "(" << externalArgs << " : " << externalArgs.getTypes() << ")";
-  } else {
-    p.printRegion(op.body(), /*printEntryBlockArgs=*/false,
-                  /*printBlockTerminators=*/false);
-  }
-
-  p.printOptionalAttrDictWithKeyword(op.getAttrs(),
-                                     {"name", "externalConstParams"});
-}
-
 static LogicalResult verify(RewriteOp op) {
   Region &rewriteRegion = op.body();
 
   // Handle the case where the rewrite is external.
   if (op.name()) {
     if (!rewriteRegion.empty()) {
       return op.emitOpError()
              << "expected rewrite region to be empty when rewrite is external";