[mlir][EnumGen] Generate utility symbolizeEnum and stringifyEnum methods during EnumGen

[rriddle]

Summary

This revision adds generation of two utility methods during EnumGen:

llvm::Optional<EnumType> symbolizeEnum<EnumType>(llvm::StringRef)
<stringifyResult> stringifyEnum(EnumType);

This provides a generic interface for stringifying/symbolizing any enum that can be used in a template environment.

[antiagainst]

Nice! Thanks River! :)

mlir/include/mlir/Dialect/SPIRV/SPIRVOps.h

 #include "mlir/Dialect/SPIRV/SPIRVOps.h.inc"
 
 // TableGen'erated helper functions.
 //
 // Get the name used in the Op to refer to an enum value of the given
 // `EnumClass`.
 // template <typename EnumClass> StringRef attributeName();
 //
-// Get the function that can be used to symbolize an enum value.
-// template <typename EnumClass>
-// Optional<EnumClass> (*)(StringRef) symbolizeEnum();
 #include "mlir/Dialect/SPIRV/SPIRVOpUtils.inc"
 
 } // end namespace spirv
 } // end namespace mlir
 
 namespace llvm {
 
 /// spirv::Function ops hash just like pointers.

mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp

 static Optional<ValTy> parseAndVerify(SPIRVDialect const &dialect,
                                       DialectAsmParser &parser) {
   StringRef enumSpec;
   llvm::SMLoc enumLoc = parser.getCurrentLocation();
   if (parser.parseKeyword(&enumSpec)) {
     return llvm::None;
   }
 
-  auto val = spirv::symbolizeEnum<ValTy>()(enumSpec);
+  auto val = spirv::symbolizeEnum<ValTy>(enumSpec);
   if (!val)
     parser.emitError(enumLoc, "unknown attribute: '") << enumSpec << "'";
   return val;
 }
 
 template <>
 Optional<Type> parseAndVerify<Type>(SPIRVDialect const &dialect,
                                     DialectAsmParser &parser) {

mlir/lib/Dialect/SPIRV/SPIRVOps.cpp

if (parser.parseAttribute(attrVal, parser.getBuilder().getNoneType(),
                             attrName, attr)) {
     return failure();
   }
   if (!attrVal.isa<StringAttr>()) {
     return parser.emitError(loc, "expected ")
            << attrName << " attribute specified as string";
   }
   auto attrOptional =
-      spirv::symbolizeEnum<EnumClass>()(attrVal.cast<StringAttr>().getValue());
+      spirv::symbolizeEnum<EnumClass>(attrVal.cast<StringAttr>().getValue());
   if (!attrOptional) {
     return parser.emitError(loc, "invalid ")
            << attrName << " attribute specification: " << attrVal;
   }
   value = attrOptional.getValue();
   return success();
 }
 

 static ParseResult
 parseEnumKeywordAttr(EnumClass &value, OpAsmParser &parser,
                      StringRef attrName = spirv::attributeName<EnumClass>()) {
   StringRef keyword;
   SmallVector<NamedAttribute, 1> attr;
   auto loc = parser.getCurrentLocation();
   if (parser.parseKeyword(&keyword))
     return failure();
-  if (Optional<EnumClass> attr = spirv::symbolizeEnum<EnumClass>()(keyword)) {
+  if (Optional<EnumClass> attr = spirv::symbolizeEnum<EnumClass>(keyword)) {
     value = attr.getValue();
     return success();
   }
   return parser.emitError(loc, "invalid ")
          << attrName << " attribute specification: " << keyword;
 }
 
 /// Parses the next keyword in `parser` as an enumerant of the given `EnumClass`

mlir/tools/mlir-tblgen/EnumsGen.cpp

os << formatv("llvm::Optional<{0}> {1}(llvm::StringRef);\n", enumName,
                 strToSymFnName);
 
   if (enumAttr.isBitEnum()) {
     emitOperators(enumDef, os);
   } else {
     emitMaxValueFn(enumDef, os);
   }
 
+  // Generate a generic `stringifyEnum` function that forwards to the method
+  // specified by the user.
+  const char *const stringifyEnumStr = R"(
+inline {0} stringifyEnum({1} enumValue) {{
+  return {2}(enumValue);
+}
+)";
+  os << formatv(stringifyEnumStr, symToStrFnRetType, enumName, symToStrFnName);
+
+  // Generate a generic `symbolizeEnum` function that forwards to the method
+  // specified by the user.
+  const char *const symbolizeEnumStr = R"(
+template <typename EnumType>
+llvm::Optional<EnumType> symbolizeEnum(llvm::StringRef);
+
+template <>
+inline llvm::Optional<{0}> symbolizeEnum<{0}>(llvm::StringRef str) {
+  return {1}(str);
+}
+)";
+  os << formatv(symbolizeEnumStr, enumName, strToSymFnName);
+
   for (auto ns : llvm::reverse(namespaces))
     os << "} // namespace " << ns << "\n";
 
   // Emit DenseMapInfo for this enum class
   emitDenseMapInfo(enumName, underlyingType, cppNamespace, os);
 }
 
 static bool emitEnumDecls(const RecordKeeper &recordKeeper, raw_ostream &os) {

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

 // Op Utils AutoGen
 //===----------------------------------------------------------------------===//
 
 static void emitEnumGetAttrNameFnDecl(raw_ostream &os) {
   os << formatv("template <typename EnumClass> inline constexpr StringRef "
                 "attributeName();\n");
 }
 
-static void emitEnumGetSymbolizeFnDecl(raw_ostream &os) {
-  os << "template <typename EnumClass> using SymbolizeFnTy = "
-        "llvm::Optional<EnumClass> (*)(StringRef);\n";
-  os << "template <typename EnumClass> inline constexpr "
-        "SymbolizeFnTy<EnumClass> symbolizeEnum();\n";
-}
-
 static void emitEnumGetAttrNameFnDefn(const EnumAttr &enumAttr,
                                       raw_ostream &os) {
   auto enumName = enumAttr.getEnumClassName();
   os << formatv("template <> inline StringRef attributeName<{0}>() {{\n",
                 enumName);
   os << "  "
      << formatv("static constexpr const char attrName[] = \"{0}\";\n",
                 mlir::convertToSnakeCase(enumName));
   os << "  return attrName;\n";
   os << "}\n";
 }
 
-static void emitEnumGetSymbolizeFnDefn(const EnumAttr &enumAttr,
-                                       raw_ostream &os) {
-  auto enumName = enumAttr.getEnumClassName();
-  auto strToSymFnName = enumAttr.getStringToSymbolFnName();
-  os << formatv(
-      "template <> inline SymbolizeFnTy<{0}> symbolizeEnum<{0}>() {{\n",
-      enumName);
-  os << "  return " << strToSymFnName << ";\n";
-  os << "}\n";
-}
-
 static bool emitOpUtils(const RecordKeeper &recordKeeper, raw_ostream &os) {
   llvm::emitSourceFileHeader("SPIR-V Op Utilities", os);
 
   auto defs = recordKeeper.getAllDerivedDefinitions("EnumAttrInfo");
   os << "#ifndef SPIRV_OP_UTILS_H_\n";
   os << "#define SPIRV_OP_UTILS_H_\n";
   emitEnumGetAttrNameFnDecl(os);
-  emitEnumGetSymbolizeFnDecl(os);
   for (const auto *def : defs) {
     EnumAttr enumAttr(*def);
     emitEnumGetAttrNameFnDefn(enumAttr, os);
-    emitEnumGetSymbolizeFnDefn(enumAttr, os);
   }
   os << "#endif // SPIRV_OP_UTILS_H\n";
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // Op Utils Hook Registration
 //===----------------------------------------------------------------------===//