[mlir][ods] BitEnumAttr: Actually use the 'str' for the all unset case

mlir/test/mlir-tblgen/enums-gen.td

 // RUN: mlir-tblgen -gen-enum-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
 // RUN: mlir-tblgen -gen-enum-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
 
 include "mlir/IR/EnumAttr.td"
 include "mlir/IR/OpBase.td"
 
 // Test bit enums
-def None: I32BitEnumAttrCaseNone<"None">;
+def None: I32BitEnumAttrCaseNone<"None", "none">;
 def Bit0: I32BitEnumAttrCaseBit<"Bit0", 0, "tagged">;
 def Bit1: I32BitEnumAttrCaseBit<"Bit1", 1>;
 def Bit2: I32BitEnumAttrCaseBit<"Bit2", 2>;
 def Bit3: I32BitEnumAttrCaseBit<"Bit3", 3>;
 def BitGroup: I32BitEnumAttrCaseGroup<"BitGroup", [
   Bit0, Bit1
 ]>;
 

 // DECL:   }
 // DECL:   auto underlyingValue = static_cast<std::make_unsigned_t<::MyBitEnum>>(value);
 // DECL:   if (underlyingValue && !llvm::has_single_bit(underlyingValue))
 // DECL:     return p << '"' << valueStr << '"';
 // DECL:   return p << valueStr;
 
 // DEF-LABEL: std::string stringifyMyBitEnum
 // DEF: auto val = static_cast<uint32_t>
-// DEF: if (val == 0) return "None";
+// DEF: if (val == 0) return "none";
 // DEF: if (1u == (1u & val))
 // DEF-NEXT: push_back("tagged")
 // DEF: if (2u == (2u & val))
 // DEF-NEXT: push_back("Bit1")
 
 // DEF-LABEL: ::llvm::Optional<MyBitEnum> symbolizeMyBitEnum(::llvm::StringRef str)
-// DEF: if (str == "None") return MyBitEnum::None;
+// DEF: if (str == "none") return MyBitEnum::None;
 // DEF: .Case("tagged", 1)
 // DEF: .Case("Bit1", 2)
 
 // Test enum printer generation for non non-keyword enums.
 
 def NonKeywordBit: I32BitEnumAttrCaseBit<"Bit0", 0, "tag-ged">;
 def MyMixedNonKeywordBitEnum: I32BitEnumAttr<"MyMixedNonKeywordBitEnum", "An example bit enum", [
     NonKeywordBit,

mlir/tools/mlir-tblgen/EnumsGen.cpp

)";
   // case value to determine when to print in the string form.
   if (nonKeywordCases.any()) {
     os << "  switch (value) {\n";
     for (auto &it : llvm::enumerate(cases)) {
       if (nonKeywordCases.test(it.index()))
         continue;
       StringRef symbol = it.value().getSymbol();
       os << llvm::formatv("  case {0}::{1}:\n", qualName,
-                          llvm::isDigit(symbol.front()) ? ("_" + symbol)
-                                                        : symbol);
+                          makeIdentifier(symbol));
     }
     os << "    break;\n"
           "  default:\n"
           "    return p << '\"' << valueStr << '\"';\n"
           "  }\n";
 
     // If this is a bit enum, conservatively print the string form if the value
     // is not a power of two (i.e. not a single bit case) and not a known case.
static void emitSymToStrFnForBitEnum(const Record &enumDef, raw_ostream &os) {
   // If we have unknown bit set, return an empty string to signal errors.
   int64_t validBits = enumDef.getValueAsInt("validBits");
   os << formatv("  assert({0}u == ({0}u | val) && \"invalid bits set in bit "
                 "enum\");\n",
                 validBits);
   if (allBitsUnsetCase) {
     os << "  // Special case for all bits unset.\n";
     os << formatv("  if (val == 0) return \"{0}\";\n\n",
-                  allBitsUnsetCase->getSymbol());
+                  allBitsUnsetCase->getStr());
   }
   os << "  ::llvm::SmallVector<::llvm::StringRef, 2> strs;\n";
 
   // Add case string if the value has all case bits, and remove them to avoid
   // printing again. Used only for groups, when printBitEnumPrimaryGroups is 1.
   const char *const formatCompareRemove = R"(
   if ({0}u == ({0}u & val)) {{
     strs.push_back("{1}");
static void emitStrToSymFnForBitEnum(const Record &enumDef, raw_ostream &os) {
 
   os << formatv("::llvm::Optional<{0}> {1}(::llvm::StringRef str) {{\n",
                 enumName, strToSymFnName);
 
   if (allBitsUnsetCase) {
     os << "  // Special case for all bits unset.\n";
     StringRef caseSymbol = allBitsUnsetCase->getSymbol();
     os << formatv("  if (str == \"{1}\") return {0}::{2};\n\n", enumName,
-                  caseSymbol, makeIdentifier(caseSymbol));
+                  allBitsUnsetCase->getStr(), makeIdentifier(caseSymbol));
   }
 
   // Split the string to get symbols for all the bits.
   os << "  ::llvm::SmallVector<::llvm::StringRef, 2> symbols;\n";
   // Remove whitespace from the separator string when parsing.
   os << formatv("  str.split(symbols, \"{0}\");\n\n", separatorTrimmed);
 
   os << formatv("  {0} val = 0;\n", underlyingType);