[mlir] Use _odsPrinter for printer name in generated code

[jpienaar]

Summary

The generated name should not be load bearing, so this should be a NFC change.

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 const char *regionSingleBlockImplicitTerminatorPrinterCode = R"(
   {
     bool printTerminator = true;
     if (auto *term = {0}.empty() ? nullptr : {0}.begin()->getTerminator()) {{
       printTerminator = !term->getAttrDictionary().empty() ||
                         term->getNumOperands() != 0 ||
                         term->getNumResults() != 0;
     }
-    p.printRegion({0}, /*printEntryBlockArgs=*/true,
-                  /*printBlockTerminators=*/printTerminator);
+    _odsPrinter.printRegion({0}, /*printEntryBlockArgs=*/true,
   }
 )";
 
 /// The code snippet used to generate a printer call for an enum that has cases
 /// that can't be represented with a keyword.
 ///
 /// {0}: The name of the enum attribute.
 /// {1}: The name of the enum attributes symbolToString function.
 const char *enumAttrBeginPrinterCode = R"(
   {
     auto caseValue = {0}();
     auto caseValueStr = {1}(caseValue);
 )";
 
 /// Generate the printer for the 'attr-dict' directive.
 static void genAttrDictPrinter(OperationFormat &fmt, Operator &op,
                                OpMethodBody &body, bool withKeyword) {
-  body << "  p.printOptionalAttrDict" << (withKeyword ? "WithKeyword" : "")
+  body << "  _odsPrinter.printOptionalAttrDict"
+       << (withKeyword ? "WithKeyword" : "")
        << "((*this)->getAttrs(), /*elidedAttrs=*/{";
   // Elide the variadic segment size attributes if necessary.
   if (!fmt.allOperands &&
       op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments"))
     body << "\"operand_segment_sizes\", ";
   if (!fmt.allResultTypes &&
       op.getTrait("::mlir::OpTrait::AttrSizedResultSegments"))
     body << "\"result_segment_sizes\", ";
   if (!fmt.inferredAttributes.empty()) {
     for (const auto &attr : fmt.inferredAttributes)
       body << "\"" << attr.getKey() << "\", ";
   }
   llvm::interleaveComma(
       fmt.usedAttributes, body,
       [&](const NamedAttribute *attr) { body << "\"" << attr->name << "\""; });
   body << "});\n";
 }
 
 /// Generate the printer for a literal value. `shouldEmitSpace` is true if a
 /// space should be emitted before this element. `lastWasPunctuation` is true if
 /// the previous element was a punctuation literal.
 static void genLiteralPrinter(StringRef value, OpMethodBody &body,
                               bool &shouldEmitSpace, bool &lastWasPunctuation) {
-  body << "  p";
+  body << "  _odsPrinter";
 
   // Don't insert a space for certain punctuation.
   auto shouldPrintSpaceBeforeLiteral = [&] {
     if (value.size() != 1 && value != "->")
       return true;
     if (lastWasPunctuation)
       return !StringRef(">)}],").contains(value.front());
     return !StringRef("<>(){}[],").contains(value.front());
   };
   if (shouldEmitSpace && shouldPrintSpaceBeforeLiteral())
     body << " << ' '";
   body << " << \"" << value << "\";\n";
 
   // Insert a space after certain literals.
   shouldEmitSpace =
       value.size() != 1 || !StringRef("<({[").contains(value.front());
   lastWasPunctuation = !(value.front() == '_' || isalpha(value.front()));
 }
 
 /// Generate the printer for a space. `shouldEmitSpace` and `lastWasPunctuation`
 /// are set to false.
 static void genSpacePrinter(bool value, OpMethodBody &body,
                             bool &shouldEmitSpace, bool &lastWasPunctuation) {
   if (value) {
-    body << "  p << ' ';\n";
+    body << "  _odsPrinter << ' ';\n";
     lastWasPunctuation = false;
   } else {
     lastWasPunctuation = true;
   }
   shouldEmitSpace = false;
 }
 
 /// Generate the printer for a custom directive parameter.
static void genCustomDirectiveParameterPrinter(Element *element,
   } else {
     llvm_unreachable("unknown custom directive parameter");
   }
 }
 
 /// Generate the printer for a custom directive.
 static void genCustomDirectivePrinter(CustomDirective *customDir,
                                       const Operator &op, OpMethodBody &body) {
-  body << "  print" << customDir->getName() << "(p, *this";
+  body << "  print" << customDir->getName() << "(_odsPrinter, *this";
   for (Element &param : customDir->getArguments()) {
     body << ", ";
     genCustomDirectiveParameterPrinter(&param, op, body);
   }
   body << ");\n";
 }
 
 /// Generate the printer for a region with the given variable name.
 static void genRegionPrinter(const Twine &regionName, OpMethodBody &body,
                              bool hasImplicitTermTrait) {
   if (hasImplicitTermTrait)
     body << llvm::formatv(regionSingleBlockImplicitTerminatorPrinterCode,
                           regionName);
   else
-    body << "  p.printRegion(" << regionName << ");\n";
+    body << "  _odsPrinter.printRegion(" << regionName << ");\n";
 }
 static void genVariadicRegionPrinter(const Twine &regionListName,
                                      OpMethodBody &body,
                                      bool hasImplicitTermTrait) {
   body << "    llvm::interleaveComma(" << regionListName
-       << ", p, [&](::mlir::Region &region) {\n      ";
+       << ", _odsPrinter, [&](::mlir::Region &region) {\n      ";
   genRegionPrinter("region", body, hasImplicitTermTrait);
   body << "    });\n";
 }
 
 /// Generate the C++ for an operand to a (*-)type directive.
 static OpMethodBody &genTypeOperandPrinter(Element *arg, const Operator &op,
                                            OpMethodBody &body) {
   if (isa<OperandsDirective>(arg))
static void genEnumAttrPrinter(const NamedAttribute *var, const Operator &op,
   // need to use the string form.
   if (hasStrCase) {
     if (nonKeywordCases.any()) {
       body << "    if (llvm::is_contained(llvm::ArrayRef<llvm::StringRef>(";
       llvm::interleaveComma(nonKeywordCases.set_bits(), body, [&](unsigned it) {
         body << '"' << cases[it].getStr() << '"';
       });
       body << ")))\n"
-              "      p << '\"' << caseValueStr << '\"';\n"
+              "      _odsPrinter << '\"' << caseValueStr << '\"';\n"
               "    else\n  ";
     }
-    body << "    p << caseValueStr;\n"
+    body << "    _odsPrinter << caseValueStr;\n"
             "  }\n";
     return;
   }
 
   // Otherwise if this is a bit enum attribute, don't allow cases that may
   // overlap with other cases. For simplicity sake, only allow cases with a
   // single bit value.
   if (enumAttr.isBitEnum()) {
if (nonKeywordCases.any()) {
     for (auto it : llvm::enumerate(cases)) {
       if (nonKeywordCases.test(it.index()))
         continue;
       StringRef symbol = it.value().getSymbol();
       body << llvm::formatv("    case {0}::{1}::{2}:\n", cppNamespace, enumName,
                             llvm::isDigit(symbol.front()) ? ("_" + symbol)
                                                           : symbol);
     }
-    body << "      p << caseValueStr;\n"
+    body << "      _odsPrinter << caseValueStr;\n"
             "      break;\n"
             "    default:\n"
-            "      p << '\"' << caseValueStr << '\"';\n"
+            "      _odsPrinter << '\"' << caseValueStr << '\"';\n"
             "      break;\n"
             "    }\n"
             "  }\n";
     return;
   }
 
-  body << "    p << caseValueStr;\n"
+  body << "    _odsPrinter << caseValueStr;\n"
           "  }\n";
 }
 
 /// Generate the check for the anchor of an optional group.
 static void genOptionalGroupPrinterAnchor(Element *anchor, const Operator &op,
                                           OpMethodBody &body) {
   TypeSwitch<Element *>(anchor)
       .Case<OperandVariable, ResultVariable>([&](auto *element) {
void OperationFormat::genElementPrinter(Element *element, OpMethodBody &body,
                                         Operator &op, bool &shouldEmitSpace,
                                         bool &lastWasPunctuation) {
   if (LiteralElement *literal = dyn_cast<LiteralElement>(element))
     return genLiteralPrinter(literal->getLiteral(), body, shouldEmitSpace,
                              lastWasPunctuation);
 
   // Emit a whitespace element.
   if (isa<NewlineElement>(element)) {
-    body << "  p.printNewline();\n";
+    body << "  _odsPrinter.printNewline();\n";
     return;
   }
   if (SpaceElement *space = dyn_cast<SpaceElement>(element))
     return genSpacePrinter(space->getValue(), body, shouldEmitSpace,
                            lastWasPunctuation);
 
   // Emit an optional group.
   if (OptionalElement *optional = dyn_cast<OptionalElement>(element)) {
if (auto *attrDict = dyn_cast<AttrDictDirective>(element)) {
     genAttrDictPrinter(*this, op, body, attrDict->isWithKeyword());
     lastWasPunctuation = false;
     return;
   }
 
   // Optionally insert a space before the next element. The AttrDict printer
   // already adds a space as necessary.
   if (shouldEmitSpace || !lastWasPunctuation)
-    body << "  p << ' ';\n";
+    body << "  _odsPrinter << ' ';\n";
   lastWasPunctuation = false;
   shouldEmitSpace = true;
 
   if (auto *attr = dyn_cast<AttributeVariable>(element)) {
     const NamedAttribute *var = attr->getVar();
 
     // If we are formatting as an enum, symbolize the attribute as a string.
     if (canFormatEnumAttr(var))
       return genEnumAttrPrinter(var, op, body);
 
     // If we are formatting as a symbol name, handle it as a symbol name.
     if (shouldFormatSymbolNameAttr(var)) {
-      body << "  p.printSymbolName(" << op.getGetterName(var->name)
+      body << "  _odsPrinter.printSymbolName(" << op.getGetterName(var->name)
            << "Attr().getValue());\n";
       return;
     }
 
     // Elide the attribute type if it is buildable.
     if (attr->getTypeBuilder())
-      body << "  p.printAttributeWithoutType(" << op.getGetterName(var->name)
-           << "Attr());\n";
+      body << "  _odsPrinter.printAttributeWithoutType("
+           << op.getGetterName(var->name) << "Attr());\n";
     else
-      body << "  p.printAttribute(" << op.getGetterName(var->name)
+      body << "  _odsPrinter.printAttribute(" << op.getGetterName(var->name)
            << "Attr());\n";
   } else if (auto *operand = dyn_cast<OperandVariable>(element)) {
     if (operand->getVar()->isVariadicOfVariadic()) {
       body << "  ::llvm::interleaveComma("
            << op.getGetterName(operand->getVar()->name)
-           << "(), p, [&](const auto &operands) { p << \"(\" << operands << "
+           << "(), _odsPrinter, [&](const auto &operands) { _odsPrinter << "
+              "\"(\" << operands << "
               "\")\"; });\n";
 
     } else if (operand->getVar()->isOptional()) {
       body << "  if (::mlir::Value value = "
            << op.getGetterName(operand->getVar()->name) << "())\n"
-           << "    p << value;\n";
+           << "    _odsPrinter << value;\n";
     } else {
-      body << "  p << " << op.getGetterName(operand->getVar()->name) << "();\n";
+      body << "  _odsPrinter << " << op.getGetterName(operand->getVar()->name)
+           << "();\n";
     }
   } else if (auto *region = dyn_cast<RegionVariable>(element)) {
     const NamedRegion *var = region->getVar();
     std::string name = op.getGetterName(var->name);
     if (var->isVariadic()) {
       genVariadicRegionPrinter(name + "()", body, hasImplicitTermTrait);
     } else {
       genRegionPrinter(name + "()", body, hasImplicitTermTrait);
     }
   } else if (auto *successor = dyn_cast<SuccessorVariable>(element)) {
     const NamedSuccessor *var = successor->getVar();
     std::string name = op.getGetterName(var->name);
     if (var->isVariadic())
-      body << "  ::llvm::interleaveComma(" << name << "(), p);\n";
+      body << "  ::llvm::interleaveComma(" << name << "(), _odsPrinter);\n";
     else
-      body << "  p << " << name << "();\n";
+      body << "  _odsPrinter << " << name << "();\n";
   } else if (auto *dir = dyn_cast<CustomDirective>(element)) {
     genCustomDirectivePrinter(dir, op, body);
   } else if (isa<OperandsDirective>(element)) {
-    body << "  p << getOperation()->getOperands();\n";
+    body << "  _odsPrinter << getOperation()->getOperands();\n";
   } else if (isa<RegionsDirective>(element)) {
     genVariadicRegionPrinter("getOperation()->getRegions()", body,
                              hasImplicitTermTrait);
   } else if (isa<SuccessorsDirective>(element)) {
-    body << "  ::llvm::interleaveComma(getOperation()->getSuccessors(), p);\n";
+    body << "  ::llvm::interleaveComma(getOperation()->getSuccessors(), "
+            "_odsPrinter);\n";
   } else if (auto *dir = dyn_cast<TypeDirective>(element)) {
     if (auto *operand = dyn_cast<OperandVariable>(dir->getOperand())) {
       if (operand->getVar()->isVariadicOfVariadic()) {
-        body << llvm::formatv("  ::llvm::interleaveComma({0}().getTypes(), p, "
-                              "[&](::mlir::TypeRange types) {{ p << \"(\" << "
-                              "types << \")\"; });\n",
-                              op.getGetterName(operand->getVar()->name));
+        body << llvm::formatv(
+            "  ::llvm::interleaveComma({0}().getTypes(), _odsPrinter, "
+            "[&](::mlir::TypeRange types) {{ _odsPrinter << \"(\" << "
         return;
       }
     }
-    body << "  p << ";
+    body << "  _odsPrinter << ";
     genTypeOperandPrinter(dir->getOperand(), op, body) << ";\n";
   } else if (auto *dir = dyn_cast<FunctionalTypeDirective>(element)) {
-    body << "  p.printFunctionalType(";
+    body << "  _odsPrinter.printFunctionalType(";
     genTypeOperandPrinter(dir->getInputs(), op, body) << ", ";
     genTypeOperandPrinter(dir->getResults(), op, body) << ");\n";
   } else {
     llvm_unreachable("unknown format element");
   }
 }
 
 void OperationFormat::genPrinter(Operator &op, OpClass &opClass) {
-  auto *method =
-      opClass.addMethodAndPrune("void", "print", "::mlir::OpAsmPrinter &p");
+  auto *method = opClass.addMethodAndPrune("void", "print",
+                                           "::mlir::OpAsmPrinter &_odsPrinter");
   auto &body = method->body();
 
   // Flags for if we should emit a space, and if the last element was
   // punctuation.
   bool shouldEmitSpace = true, lastWasPunctuation = false;
   for (auto &element : elements)
     genElementPrinter(element.get(), body, op, shouldEmitSpace,
                       lastWasPunctuation);