[mlir:ODS] Deprecate Op parser/printer fields in favor of a new hasCustomAssemblyFormat field

[rriddle]

Summary

Currently if an operation wants a C++ implemented parser/printer, it specifies inline
code blocks. This is quite problematic for various reasons, e.g. it requires defining
C++ inside of Tablegen which is discouraged when possible, but mainly because
nearly all usages simply forward to static functions (e.g. static void parseSomeOp(...))
with users devising their own standards for how these are defined.

This commit adds support for a hasCustomAssemblyFormat bit field that specifies if
a C++ parser/printer is needed, and when set to 1 declares the parse/print methods for
operations to override. For migration purposes, the existing behavior is untouched. Upstream
usages will be replaced in a followup to keep this patch focused on the new implementation.

[rriddle]

hasCppAssemblyFormat was the best name my brain could come up with quickly, happy to shift it to something else.

[mehdi_amini]

I don't have a better naming suggestion just now!

[lattner]

Awesome, very excited about this. In terms of name, WDYT about hasCustomAssemblyFormat? You're right that Cpp is more technically correct, but I think we generally call manually written C++ as the "custom" stuff.

[mehdi_amini]

The reason I didn't suggest hasCustomAssemblyFormat is that it puts the declarative assembly form as a "non custom format" somehow. But since this is all within ODS this may not be that confusing.

[rriddle]

In D119054#3299497, @mehdi_amini wrote:

The reason I didn't suggest hasCustomAssemblyFormat is that it puts the declarative assembly form as a "non custom format" somehow. But since this is all within ODS this may not be that confusing.

This is also why I didn't use that name initially. We refer to any derived assembly format as a being a "custom assembly format" (including the declarative form). Maybe this doesn't matter given hasCustomAssemblyFormat/assemblyFormat can just be treated as two ways to get a custom assembly format (and the Custom here is limited to an ODS context). Either way renaming this in the future is trivial (it's just a field).

[jpienaar]

mlir/include/mlir/IR/OpBase.td

2448–2449

Could you emit a warning from ODS when these are set to warn folks that these are deprecated?

mlir/include/mlir/IR/OpBase.td

class Op<Dialect dialect, string mnemonic, list<Trait> props = []> {
   //                   ArrayRef<NamedAttribute> attributes);
   // ```
   list<OpBuilder> builders = ?;
 
   // Avoid generating default build functions.  Custom builders must be
   // provided.
   bit skipDefaultBuilders = 0;
 
-  // Custom parser.
+  // Custom parser and printer.
+  // NOTE: These fields are deprecated in favor of `assemblyFormat` or
+  // `hasCustomAssemblyFormat`, and are slated for deletion.
   code parser = ?;
-
-  // Custom printer.
   code printer = ?;
 
   // Custom assembly format.
+  /// This field corresponds to a declarative description of the assembly format
+  /// for this operation. If populated, the `hasCustomAssemblyFormat` field is
+  /// ignored.
   string assemblyFormat = ?;
+  /// This field indicates that the operation has a custom assembly format
+  /// implemented in C++. When set to `1` a `parse` and `print` method are generated
+  /// on the operation class. The operation should implement these methods to
+  /// support the custom format of the operation. The methods have the form:
+  ///   * ParseResult parse(OpAsmParser &parser, OperationState &result)
+  ///   * void print(OpAsmPrinter &p)
+  bit hasCustomAssemblyFormat = 0;
 
   // A bit indicating if the operation has additional invariants that need to
   // verified (aside from those verified by other ODS constructs). If set to `1`,
   // an additional `LogicalResult verify()` declaration will be generated on the
   // operation class. The operation should implement this method and verify the
   // additional necessary invariants.
   bit hasVerifier = 0;
   // A custom code block corresponding to the extra verification code of the

mlir/test/lib/Dialect/Test/TestDialect.cpp

static void printCustomDirectiveOptionalOperandRef(OpAsmPrinter &printer,
                                                    Value optOperand) {
   printer << (optOperand ? "1" : "0");
 }
 
 //===----------------------------------------------------------------------===//
 // Test IsolatedRegionOp - parse passthrough region arguments.
 //===----------------------------------------------------------------------===//
 
-static ParseResult parseIsolatedRegionOp(OpAsmParser &parser,
-                                         OperationState &result) {
+ParseResult IsolatedRegionOp::parse(OpAsmParser &parser,
   OpAsmParser::OperandType argInfo;
   Type argType = parser.getBuilder().getIndexType();
 
   // Parse the input operand.
   if (parser.parseOperand(argInfo) ||
       parser.resolveOperand(argInfo, argType, result.operands))
     return failure();
 
   // Parse the body region, and reuse the operand info as the argument info.
   Region *body = result.addRegion();
   return parser.parseRegion(*body, argInfo, argType, /*argLocations=*/{},
                             /*enableNameShadowing=*/true);
 }
 
-static void print(OpAsmPrinter &p, IsolatedRegionOp op) {
+void IsolatedRegionOp::print(OpAsmPrinter &p) {
   p << "test.isolated_region ";
-  p.printOperand(op.getOperand());
-  p.shadowRegionArgs(op.getRegion(), op.getOperand());
+  p.printOperand(getOperand());
+  p.shadowRegionArgs(getRegion(), getOperand());
   p << ' ';
-  p.printRegion(op.getRegion(), /*printEntryBlockArgs=*/false);
+  p.printRegion(getRegion(), /*printEntryBlockArgs=*/false);
 }
 
 //===----------------------------------------------------------------------===//
 // Test SSACFGRegionOp
 //===----------------------------------------------------------------------===//
 
 RegionKind SSACFGRegionOp::getRegionKind(unsigned index) {
   return RegionKind::SSACFG;
 }
 
 //===----------------------------------------------------------------------===//
 // Test GraphRegionOp
 //===----------------------------------------------------------------------===//
 
-static ParseResult parseGraphRegionOp(OpAsmParser &parser,
-                                      OperationState &result) {
+ParseResult GraphRegionOp::parse(OpAsmParser &parser, OperationState &result) {
   // Parse the body region, and reuse the operand info as the argument info.
   Region *body = result.addRegion();
   return parser.parseRegion(*body, /*arguments=*/{}, /*argTypes=*/{});
 }
 
-static void print(OpAsmPrinter &p, GraphRegionOp op) {
+void GraphRegionOp::print(OpAsmPrinter &p) {
   p << "test.graph_region ";
-  p.printRegion(op.getRegion(), /*printEntryBlockArgs=*/false);
+  p.printRegion(getRegion(), /*printEntryBlockArgs=*/false);
 }
 
 RegionKind GraphRegionOp::getRegionKind(unsigned index) {
   return RegionKind::Graph;
 }
 
 //===----------------------------------------------------------------------===//
 // Test AffineScopeOp
 //===----------------------------------------------------------------------===//
 
-static ParseResult parseAffineScopeOp(OpAsmParser &parser,
-                                      OperationState &result) {
+ParseResult AffineScopeOp::parse(OpAsmParser &parser, OperationState &result) {
   // Parse the body region, and reuse the operand info as the argument info.
   Region *body = result.addRegion();
   return parser.parseRegion(*body, /*arguments=*/{}, /*argTypes=*/{});
 }
 
-static void print(OpAsmPrinter &p, AffineScopeOp op) {
+void AffineScopeOp::print(OpAsmPrinter &p) {
   p << "test.affine_scope ";
-  p.printRegion(op.getRegion(), /*printEntryBlockArgs=*/false);
+  p.printRegion(getRegion(), /*printEntryBlockArgs=*/false);
 }
 
 //===----------------------------------------------------------------------===//
 // Test parser.
 //===----------------------------------------------------------------------===//
 
-static ParseResult parseParseIntegerLiteralOp(OpAsmParser &parser,
-                                              OperationState &result) {
+ParseResult ParseIntegerLiteralOp::parse(OpAsmParser &parser,
   if (parser.parseOptionalColon())
     return success();
   uint64_t numResults;
   if (parser.parseInteger(numResults))
     return failure();
 
   IndexType type = parser.getBuilder().getIndexType();
   for (unsigned i = 0; i < numResults; ++i)
     result.addTypes(type);
   return success();
 }
 
-static void print(OpAsmPrinter &p, ParseIntegerLiteralOp op) {
-  if (unsigned numResults = op->getNumResults())
+void ParseIntegerLiteralOp::print(OpAsmPrinter &p) {
+  if (unsigned numResults = getNumResults())
     p << " : " << numResults;
 }
 
-static ParseResult parseParseWrappedKeywordOp(OpAsmParser &parser,
-                                              OperationState &result) {
+ParseResult ParseWrappedKeywordOp::parse(OpAsmParser &parser,
   StringRef keyword;
   if (parser.parseKeyword(&keyword))
     return failure();
   result.addAttribute("keyword", parser.getBuilder().getStringAttr(keyword));
   return success();
 }
 
-static void print(OpAsmPrinter &p, ParseWrappedKeywordOp op) {
-  p << " " << op.getKeyword();
-}
+void ParseWrappedKeywordOp::print(OpAsmPrinter &p) { p << " " << getKeyword(); }
 
 //===----------------------------------------------------------------------===//
 // Test WrapRegionOp - wrapping op exercising `parseGenericOperation()`.
 
-static ParseResult parseWrappingRegionOp(OpAsmParser &parser,
-                                         OperationState &result) {
+ParseResult WrappingRegionOp::parse(OpAsmParser &parser,
   if (parser.parseKeyword("wraps"))
     return failure();
 
   // Parse the wrapped op in a region
   Region &body = *result.addRegion();
   body.push_back(new Block);
   Block &block = body.back();
   Operation *wrappedOp = parser.parseGenericOperation(&block, block.begin());
result.types.append(returnOp.operand_type_begin(),
                       returnOp.operand_type_end());
 
   // Use the location of the wrapped op for the "test.wrapping_region" op.
   result.location = wrappedOp->getLoc();
 
   return success();
 }
 
-static void print(OpAsmPrinter &p, WrappingRegionOp op) {
+void WrappingRegionOp::print(OpAsmPrinter &p) {
   p << " wraps ";
-  p.printGenericOp(&op.getRegion().front().front());
+  p.printGenericOp(&getRegion().front().front());
 }
 
 //===----------------------------------------------------------------------===//
 // Test PrettyPrintedRegionOp -  exercising the following parser APIs
 //   parseGenericOperationAfterOpName
 //   parseCustomOperationName
 //===----------------------------------------------------------------------===//
 
-static ParseResult parsePrettyPrintedRegionOp(OpAsmParser &parser,
-                                              OperationState &result) {
+ParseResult PrettyPrintedRegionOp::parse(OpAsmParser &parser,
 
   SMLoc loc = parser.getCurrentLocation();
   Location currLocation = parser.getEncodedSourceLoc(loc);
 
   // Parse the operands.
   SmallVector<OpAsmParser::OperandType, 2> operands;
   if (parser.parseOperandList(operands))
     return failure();
ParseResult PrettyPrintedRegionOp::parse(OpAsmParser &parser,
 
   // Populate the op operation-state with result-type and location.
   result.addTypes(opFntype.getResults());
   result.location = innerOp->getLoc();
 
   return success();
 }
 
-static void print(OpAsmPrinter &p, PrettyPrintedRegionOp op) {
+void PrettyPrintedRegionOp::print(OpAsmPrinter &p) {
   p << ' ';
-  p.printOperands(op.getOperands());
+  p.printOperands(getOperands());
 
-  Operation &innerOp = op.getRegion().front().front();
+  Operation &innerOp = getRegion().front().front();
   // Assuming that region has a single non-terminator inner-op, if the inner-op
   // meets some criteria (which in this case is a simple one  based on the name
   // of inner-op), then we can print the entire region in a succinct way.
   // Here we assume that the prototype of "special.op" can be trivially derived
   // while parsing it back.
   if (innerOp.getName().getStringRef().equals("special.op")) {
     p << " start special.op end";
   } else {
     p << " (";
-    p.printRegion(op.getRegion());
+    p.printRegion(getRegion());
     p << ")";
   }
 
   p << " : ";
-  p.printFunctionalType(op);
+  p.printFunctionalType(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // Test PolyForOp - parse list of region arguments.
 //===----------------------------------------------------------------------===//
 
-static ParseResult parsePolyForOp(OpAsmParser &parser, OperationState &result) {
+ParseResult PolyForOp::parse(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 4> ivsInfo;
   // Parse list of region arguments without a delimiter.
   if (parser.parseRegionArgumentList(ivsInfo))
     return failure();
 
   // Parse the body region.
   Region *body = result.addRegion();
   auto &builder = parser.getBuilder();
   SmallVector<Type, 4> argTypes(ivsInfo.size(), builder.getIndexType());
   return parser.parseRegion(*body, ivsInfo, argTypes);
 }
 
+void PolyForOp::print(OpAsmPrinter &p) { p.printGenericOp(*this); }
+
 void PolyForOp::getAsmBlockArgumentNames(Region &region,
                                          OpAsmSetValueNameFn setNameFn) {
   auto arrayAttr = getOperation()->getAttrOfType<ArrayAttr>("arg_names");
   if (!arrayAttr)
     return;
   auto args = getRegion().front().getArguments();
   auto e = std::min(arrayAttr.size(), args.size());
   for (unsigned i = 0; i < e; ++i) {
void SideEffectOp::getEffects(
   testSideEffectOpGetEffect(getOperation(), effects);
 }
 
 //===----------------------------------------------------------------------===//
 // StringAttrPrettyNameOp
 //===----------------------------------------------------------------------===//
 
 // This op has fancy handling of its SSA result name.
-static ParseResult parseStringAttrPrettyNameOp(OpAsmParser &parser,
-                                               OperationState &result) {
+ParseResult StringAttrPrettyNameOp::parse(OpAsmParser &parser,
   // Add the result types.
   for (size_t i = 0, e = parser.getNumResults(); i != e; ++i)
     result.addTypes(parser.getBuilder().getIntegerType(32));
 
   if (parser.parseOptionalAttrDictWithKeyword(result.attributes))
     return failure();
 
   // If the attribute dictionary contains no 'names' attribute, infer it from
for (size_t i = 0, e = parser.getNumResults(); i != e; ++i) {
     names.push_back(nameStr);
   }
 
   auto namesAttr = parser.getBuilder().getStrArrayAttr(names);
   result.attributes.push_back({StringAttr::get(context, "names"), namesAttr});
   return success();
 }
 
-static void print(OpAsmPrinter &p, StringAttrPrettyNameOp op) {
+void StringAttrPrettyNameOp::print(OpAsmPrinter &p) {
   // Note that we only need to print the "name" attribute if the asmprinter
   // result name disagrees with it.  This can happen in strange cases, e.g.
   // when there are conflicts.
-  bool namesDisagree = op.getNames().size() != op.getNumResults();
+  bool namesDisagree = getNames().size() != getNumResults();
 
   SmallString<32> resultNameStr;
-  for (size_t i = 0, e = op.getNumResults(); i != e && !namesDisagree; ++i) {
+  for (size_t i = 0, e = getNumResults(); i != e && !namesDisagree; ++i) {
     resultNameStr.clear();
     llvm::raw_svector_ostream tmpStream(resultNameStr);
-    p.printOperand(op.getResult(i), tmpStream);
+    p.printOperand(getResult(i), tmpStream);
 
-    auto expectedName = op.getNames()[i].dyn_cast<StringAttr>();
+    auto expectedName = getNames()[i].dyn_cast<StringAttr>();
     if (!expectedName ||
         tmpStream.str().drop_front() != expectedName.getValue()) {
       namesDisagree = true;
     }
   }
 
   if (namesDisagree)
-    p.printOptionalAttrDictWithKeyword(op->getAttrs());
+    p.printOptionalAttrDictWithKeyword((*this)->getAttrs());
   else
-    p.printOptionalAttrDictWithKeyword(op->getAttrs(), {"names"});
+    p.printOptionalAttrDictWithKeyword((*this)->getAttrs(), {"names"});
 }
 
 // We set the SSA name in the asm syntax to the contents of the name
 // attribute.
 void StringAttrPrettyNameOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
 
   auto value = getNames();
if (getAttr().hasTrait<AttributeTrait::TestAttrTrait>())
     return success();
   return emitError("'attr' attribute should have trait 'TestAttrTrait'");
 }
 
 //===----------------------------------------------------------------------===//
 // RegionIfOp
 //===----------------------------------------------------------------------===//
 
-static void print(OpAsmPrinter &p, RegionIfOp op) {
+void RegionIfOp::print(OpAsmPrinter &p) {
   p << " ";
-  p.printOperands(op.getOperands());
-  p << ": " << op.getOperandTypes();
-  p.printArrowTypeList(op.getResultTypes());
+  p.printOperands(getOperands());
+  p << ": " << getOperandTypes();
+  p.printArrowTypeList(getResultTypes());
   p << " then ";
-  p.printRegion(op.getThenRegion(),
+  p.printRegion(getThenRegion(),
                 /*printEntryBlockArgs=*/true,
                 /*printBlockTerminators=*/true);
   p << " else ";
-  p.printRegion(op.getElseRegion(),
+  p.printRegion(getElseRegion(),
                 /*printEntryBlockArgs=*/true,
                 /*printBlockTerminators=*/true);
   p << " join ";
-  p.printRegion(op.getJoinRegion(),
+  p.printRegion(getJoinRegion(),
                 /*printEntryBlockArgs=*/true,
                 /*printBlockTerminators=*/true);
 }
 
-static ParseResult parseRegionIfOp(OpAsmParser &parser,
-                                   OperationState &result) {
+ParseResult RegionIfOp::parse(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 2> operandInfos;
   SmallVector<Type, 2> operandTypes;
 
   result.regions.reserve(3);
   Region *thenRegion = result.addRegion();
   Region *elseRegion = result.addRegion();
   Region *joinRegion = result.addRegion();
 
void AnyCondOp::getRegionInvocationBounds(
     SmallVectorImpl<InvocationBounds> &invocationBounds) {
   invocationBounds.emplace_back(1, 1);
 }
 
 //===----------------------------------------------------------------------===//
 // SingleNoTerminatorCustomAsmOp
 //===----------------------------------------------------------------------===//
 
-static ParseResult parseSingleNoTerminatorCustomAsmOp(OpAsmParser &parser,
-                                                      OperationState &state) {
+ParseResult SingleNoTerminatorCustomAsmOp::parse(OpAsmParser &parser,
   Region *body = state.addRegion();
   if (parser.parseRegion(*body, /*arguments=*/{}, /*argTypes=*/{}))
     return failure();
   return success();
 }
 
-static void print(SingleNoTerminatorCustomAsmOp op, OpAsmPrinter &printer) {
+void SingleNoTerminatorCustomAsmOp::print(OpAsmPrinter &printer) {
   printer.printRegion(
-      op.getRegion(), /*printEntryBlockArgs=*/false,
+      getRegion(), /*printEntryBlockArgs=*/false,
       // This op has a single block without terminators. But explicitly mark
       // as not printing block terminators for testing.
       /*printBlockTerminators=*/false);
 }
 
 #include "TestOpEnums.cpp.inc"
 #include "TestOpInterfaces.cpp.inc"
 #include "TestOpStructs.cpp.inc"
 #include "TestTypeInterfaces.cpp.inc"
 
 #define GET_OP_CLASSES
 #include "TestOps.cpp.inc"

mlir/test/lib/Dialect/Test/TestOps.td

def SingleNoTerminatorOp : TEST_Op<"single_no_terminator_op",
   let regions = (region SizedRegion<1>:$my_region);
 
   let assemblyFormat = "attr-dict `:` $my_region";
 }
 
 def SingleNoTerminatorCustomAsmOp : TEST_Op<"single_no_terminator_custom_asm_op",
                                             [SingleBlock, NoTerminator]> {
   let regions = (region SizedRegion<1>);
-  let parser = [{ return ::parseSingleNoTerminatorCustomAsmOp(parser, result); }];
-  let printer = [{ return ::print(*this, p); }];
+  let hasCustomAssemblyFormat = 1;
 }
 
 def VariadicNoTerminatorOp : TEST_Op<"variadic_no_terminator_op",
                                      GraphRegionNoTerminator.traits> {
   let regions = (region VariadicRegion<SizedRegion<1>>:$my_regions);
 
   let assemblyFormat = "attr-dict `:` $my_regions";
 }

 
 // This is used to test encoding of a string attribute into an SSA name of a
 // pretty printed value name.
 def StringAttrPrettyNameOp
  : TEST_Op<"string_attr_pretty_name",
            [DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]> {
   let arguments = (ins StrArrayAttr:$names);
   let results = (outs Variadic<I32>:$r);
-
-  let printer = [{ return ::print(p, *this); }];
-  let parser = [{ return ::parse$cppClass(parser, result); }];
+  let hasCustomAssemblyFormat = 1;
 }
 
 // This is used to test the OpAsmOpInterface::getDefaultDialect() feature:
 // operations nested in a region under this op will drop the "test." dialect
 // prefix.
 def DefaultDialectOp : TEST_Op<"default_dialect", [OpAsmOpInterface]> {
  let regions = (region AnyRegion:$body);
   let extraClassDeclaration = [{

 }
 
 //===----------------------------------------------------------------------===//
 // Test parser.
 //===----------------------------------------------------------------------===//
 
 def ParseIntegerLiteralOp : TEST_Op<"parse_integer_literal"> {
   let results = (outs Variadic<Index>:$results);
-  let parser = [{ return ::parse$cppClass(parser, result); }];
-  let printer = [{ return ::print(p, *this); }];
+  let hasCustomAssemblyFormat = 1;
 }
 
 def ParseWrappedKeywordOp : TEST_Op<"parse_wrapped_keyword"> {
   let arguments = (ins StrAttr:$keyword);
-  let parser = [{ return ::parse$cppClass(parser, result); }];
-  let printer = [{ return ::print(p, *this); }];
+  let hasCustomAssemblyFormat = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Test region argument list parsing.
 
 def IsolatedRegionOp : TEST_Op<"isolated_region", [IsolatedFromAbove]> {
   let summary =  "isolated region operation";
   let description = [{
     Test op with an isolated region, to test passthrough region arguments. Each
     argument is of index type.
   }];
 
   let arguments = (ins Index);
   let regions = (region SizedRegion<1>:$region);
-  let parser = [{ return ::parse$cppClass(parser, result); }];
-  let printer = [{ return ::print(p, *this); }];
+  let hasCustomAssemblyFormat = 1;
 }
 
 def SSACFGRegionOp : TEST_Op<"ssacfg_region",  [
     DeclareOpInterfaceMethods<RegionKindInterface>]> {
   let summary =  "operation with an SSACFG region";
   let description = [{
     Test op that defines an SSACFG region.
   }];
 
   let regions = (region VariadicRegion<AnyRegion>:$regions);
   let arguments = (ins Variadic<AnyType>);
   let results = (outs Variadic<AnyType>);
 }
 
 def GraphRegionOp : TEST_Op<"graph_region",  [
     DeclareOpInterfaceMethods<RegionKindInterface>]> {
   let summary =  "operation with a graph region";
   let description = [{
     Test op that defines a graph region.
   }];
 
   let regions = (region AnyRegion:$region);
-  let parser = [{ return ::parse$cppClass(parser, result); }];
-  let printer = [{ return ::print(p, *this); }];
+  let hasCustomAssemblyFormat = 1;
 }
 
 def AffineScopeOp : TEST_Op<"affine_scope", [AffineScope]> {
   let summary =  "affine scope operation";
   let description = [{
     Test op that defines a new affine scope.
   }];
 
   let regions = (region SizedRegion<1>:$region);
-  let parser = [{ return ::parse$cppClass(parser, result); }];
-  let printer = [{ return ::print(p, *this); }];
+  let hasCustomAssemblyFormat = 1;
 }
 
 def WrappingRegionOp : TEST_Op<"wrapping_region",
     [SingleBlockImplicitTerminator<"TestReturnOp">]> {
   let summary =  "wrapping region operation";
   let description = [{
     Test op wrapping another op in a region, to test calling
     parseGenericOperation from the custom parser.
   }];
 
   let results = (outs Variadic<AnyType>);
   let regions = (region SizedRegion<1>:$region);
-  let parser = [{ return ::parse$cppClass(parser, result); }];
-  let printer = [{ return ::print(p, *this); }];
+  let hasCustomAssemblyFormat = 1;
 }
 
 def PrettyPrintedRegionOp : TEST_Op<"pretty_printed_region",
     [SingleBlockImplicitTerminator<"TestReturnOp">]> {
   let summary =  "pretty_printed_region operation";
   let description = [{
     Test-op can be printed either in a "pretty" or "non-pretty" way based on
     some criteria. The custom parser parsers both the versions while testing
     APIs: parseCustomOperationName & parseGenericOperationAfterOpName.
   }];
   let arguments = (ins
     AnyType:$input1,
     AnyType:$input2
   );
 
   let results = (outs AnyType);
   let regions = (region SizedRegion<1>:$region);
-  let parser = [{ return ::parse$cppClass(parser, result); }];
-  let printer = [{ return ::print(p, *this); }];
+  let hasCustomAssemblyFormat = 1;
 }
 
-def PolyForOp : TEST_Op<"polyfor", [OpAsmOpInterface]>
-{
+def PolyForOp : TEST_Op<"polyfor", [OpAsmOpInterface]> {
   let summary =  "polyfor operation";
   let description = [{
     Test op with multiple region arguments, each argument of index type.
   }];
   let extraClassDeclaration = [{
     void getAsmBlockArgumentNames(mlir::Region &region,
                                   mlir::OpAsmSetValueNameFn setNameFn);
   }];
   let regions = (region SizedRegion<1>:$region);
-  let parser = [{ return ::parse$cppClass(parser, result); }];
+  let hasCustomAssemblyFormat = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Test OpAsmInterface.
 
 def AsmInterfaceOp : TEST_Op<"asm_interface_op"> {
   let results = (outs AnyType:$first, Variadic<AnyType>:$middle_results,
                       AnyType);
def RegionIfOp : TEST_Op<"region_if",
        SingleBlockImplicitTerminator<"RegionIfYieldOp">,
        RecursiveSideEffects]> {
   let description =[{
     Represents an abstract if-then-else-join pattern. In this context, the then
     and else regions jump to the join region, which finally returns to its
     parent op.
   }];
 
-  let printer = [{ return ::print(p, *this); }];
-  let parser = [{ return ::parseRegionIfOp(parser, result); }];
   let arguments = (ins Variadic<AnyType>);
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region SizedRegion<1>:$thenRegion,
                         AnyRegion:$elseRegion,
                         AnyRegion:$joinRegion);
   let extraClassDeclaration = [{
     ::mlir::Block::BlockArgListType getThenArgs() {
       return getBody(0)->getArguments();
     }
     ::mlir::Block::BlockArgListType getElseArgs() {
       return getBody(1)->getArguments();
     }
     ::mlir::Block::BlockArgListType getJoinArgs() {
       return getBody(2)->getArguments();
     }
     ::mlir::OperandRange getSuccessorEntryOperands(unsigned index);
   }];
+  let hasCustomAssemblyFormat = 1;
 }
 
 def AnyCondOp : TEST_Op<"any_cond",
       [DeclareOpInterfaceMethods<RegionBranchOpInterface,
                                  ["getRegionInvocationBounds"]>,
        RecursiveSideEffects]> {
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region AnyRegion:$region);

mlir/test/mlir-tblgen/op-decl-and-defs.td

def NS_AOp : NS_Op<"a_op", [IsolatedFromAbove, IsolatedFromAbove]> {
   );
 
   let regions = (region
     AnyRegion:$someRegion,
     VariadicRegion<AnyRegion>:$someRegions
   );
   let builders = [OpBuilder<(ins "Value":$val)>,
                   OpBuilder<(ins CArg<"int", "0">:$integer)>];
-  let parser = [{ foo }];
-  let printer = [{ bar }];
+  let hasCustomAssemblyFormat = 1;
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     // Display a graph for debugging purposes.
     void displayGraph();

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

for (int i = 0, e = op.getNumResults(); i != e; ++i) {
     if (types.size() == 1)
       continue;
     // TODO: We could verify equality here, but skipping that for verification.
   }
   body << "  return ::mlir::success();";
 }
 
 void OpEmitter::genParser() {
-  if (!hasStringAttribute(def, "parser") ||
-      hasStringAttribute(def, "assemblyFormat"))
+  if (hasStringAttribute(def, "assemblyFormat"))
+    return;
+
+  bool hasCppFormat = def.getValueAsBit("hasCustomAssemblyFormat");
+  if (!hasStringAttribute(def, "parser") && !hasCppFormat)
     return;
 
   SmallVector<MethodParameter> paramList;
   paramList.emplace_back("::mlir::OpAsmParser &", "parser");
   paramList.emplace_back("::mlir::OperationState &", "result");
+
+  // If this uses the cpp format, only generate a declaration.
+  if (hasCppFormat) {
+    auto *method = opClass.declareStaticMethod("::mlir::ParseResult", "parse",
+                                               std::move(paramList));
+    ERROR_IF_PRUNED(method, "parse", op);
+    return;
+  }
+
+  PrintNote(op.getLoc(),
+            "`parser` and `printer` fields are deprecated and will be removed, "
+            "please use the `hasCustomAssemblyFormat` field instead");
+
   auto *method = opClass.addStaticMethod("::mlir::ParseResult", "parse",
                                          std::move(paramList));
   ERROR_IF_PRUNED(method, "parse", op);
 
   FmtContext fctx;
   fctx.addSubst("cppClass", opClass.getClassName());
   auto parser = def.getValueAsString("parser").ltrim().rtrim(" \t\v\f\r");
   method->body() << "  " << tgfmt(parser, &fctx);
 }
 
 void OpEmitter::genPrinter() {
   if (hasStringAttribute(def, "assemblyFormat"))
     return;
 
+  // If this uses the cpp format, only generate a declaration.
+  if (def.getValueAsBit("hasCustomAssemblyFormat")) {
+    auto *method = opClass.declareMethod(
+        "void", "print", MethodParameter("::mlir::OpAsmPrinter &", "p"));
+    ERROR_IF_PRUNED(method, "print", op);
+    return;
+  }
+
   auto *valueInit = def.getValueInit("printer");
   StringInit *stringInit = dyn_cast<StringInit>(valueInit);
   if (!stringInit)
     return;
 
   auto *method = opClass.addMethod(
       "void", "print", MethodParameter("::mlir::OpAsmPrinter &", "p"));
   ERROR_IF_PRUNED(method, "print", op);