[mlir][ods] Remove StrEnumAttr

[Mogball]

Summary

StrEnumAttr has been deprecated in favour of EnumAttr, a solution based on AttrDef (https://reviews.llvm.org/D115181). This patch removes StrEnumAttr, along with all the custom ODS logic required to handle it.

See https://discourse.llvm.org/t/psa-stop-using-strenumattr-do-use-enumattr/5710 on how to transition to EnumAttr. In short,

// Before
def MyEnumAttr : StrEnumAttr<"MyEnum", "", [
  StrEnumAttrCase<"A">,
  StrEnumAttrCase<"B">
]>;

// After (pick an integer enum of your choice)
def MyEnum : I32EnumAttr<"MyEnum", "", [
  I32EnumAttrCase<"A", 0>,
  I32EnumAttrCase<"B", 1>
]> {
  // Don't generate a C++ class! We want to use the AttrDef
  let genSpecializedAttr = 0;
}
// Define the AttrDef
def MyEnum : EnumAttr<MyDialect, MyEnum, "my_enum">;

[rriddle]

Just confirming, do we have docs for the EnumAttr stuff? (Should be easier to add if not after D120011)

[rriddle]

If we don't yet have docs, can you add an EnumAttr-esque equivalent to the description as an example for users transitioning?

[jpienaar]

Nice!

[Mogball]

I don't think I had docs for EnumAttr. I updated the description, however.

mlir/docs/OpDefinitions.md

 *   `OptionalAttr`: specifies an attribute as [optional](#optional-attributes).
 *   `Confined`: adapts an attribute with
     [further constraints](#confining-attributes).
 
 ### Enum attributes
 
 Some attributes can only take values from a predefined enum, e.g., the
 comparison kind of a comparison op. To define such attributes, ODS provides
-several mechanisms: `StrEnumAttr`, `IntEnumAttr`, and `BitEnumAttr`.
+several mechanisms: `IntEnumAttr`, and `BitEnumAttr`.
 
-*   `StrEnumAttr`: each enum case is a string, the attribute is stored as a
-    [`StringAttr`][StringAttr] in the op.
 *   `IntEnumAttr`: each enum case is an integer, the attribute is stored as a
     [`IntegerAttr`][IntegerAttr] in the op.
 *   `BitEnumAttr`: each enum case is a either the empty case, a single bit,
     or a group of single bits, and the attribute is stored as a
     [`IntegerAttr`][IntegerAttr] in the op.
 
 All these `*EnumAttr` attributes require fully specifying all of the allowed
 cases via their corresponding `*EnumAttrCase`. With this, ODS is able to

mlir/include/mlir/IR/OpBase.td

class EnumAttrCaseInfo<string sym, int intVal, string strVal> {
   // If less than zero, there will be no explicit discriminator values assigned
   // to enumerators in the generated enum class.
   int value = intVal;
 
   // The string representation of the enumerant. May be the same as symbol.
   string str = strVal;
 }
 
-// An enum attribute case stored with StringAttr.
-class StrEnumAttrCase<string sym, int val = -1, string str = sym> :
-    EnumAttrCaseInfo<sym, val, str>,
-    StringBasedAttr<
-      CPred<"$_self.cast<::mlir::StringAttr>().getValue() == \"" # str # "\"">,
-      "case " # str>;
-
 // An enum attribute case stored with IntegerAttr, which has an integer value,
 // its representation as a string and a C++ symbol name which may be different.
 class IntEnumAttrCaseBase<I intType, string sym, string strVal, int intVal> :
     EnumAttrCaseInfo<sym, intVal, strVal>,
     SignlessIntegerAttrBase<intType, "case " # strVal> {
   let predicate =
     CPred<"$_self.cast<::mlir::IntegerAttr>().getInt() == " # intVal>;
 }
let returnType = !if(genSpecializedAttr,
     cppNamespace # "::" # className,
     baseAttrClass.returnType);
   let constBuilderCall = !if(genSpecializedAttr,
     cppNamespace # "::" # specializedAttrClassName # "::get($_builder.getContext(), $0)",
     baseAttrClass.constBuilderCall);
   let valueType = baseAttrClass.valueType;
 }
 
-// An enum attribute backed by StringAttr.
-//
-// Op attributes of this kind are stored as StringAttr. Extra verification will
-// be generated on the string though: only the symbols of the allowed cases are
-// permitted as the string value.
-class StrEnumAttr<string name, string summary, list<StrEnumAttrCase> cases> :
-  EnumAttrInfo<name, cases,
-    StringBasedAttr<
-      And<[StrAttr.predicate, Or<!foreach(case, cases, case.predicate)>]>,
-      !if(!empty(summary), "allowed string cases: " #
-          !interleave(!foreach(case, cases, "'" # case.symbol # "'"), ", "),
-          summary)>> {
-  // Disable specialized Attribute class for `StringAttr` backend by default.
-  let genSpecializedAttr = 0;
-}
-
 // An enum attribute backed by IntegerAttr.
 //
 // Op attributes of this kind are stored as IntegerAttr. Extra verification will
 // be generated on the integer though: only the values of the allowed cases are
 // permitted as the integer value.
 class IntEnumAttrBase<I intType, list<IntEnumAttrCaseBase> cases, string summary> :
     SignlessIntegerAttrBase<intType, summary> {
   let predicate = And<[

mlir/include/mlir/TableGen/Attribute.h

 // Wrapper class providing helper methods for accessing enum attribute cases
 // defined in TableGen. This is used for enum attribute case backed by both
 // StringAttr and IntegerAttr.
 class EnumAttrCase : public Attribute {
 public:
   explicit EnumAttrCase(const llvm::Record *record);
   explicit EnumAttrCase(const llvm::DefInit *init);
 
-  // Returns true if this EnumAttrCase is backed by a StringAttr.
-  bool isStrCase() const;
-
   // Returns the symbol of this enum attribute case.
   StringRef getSymbol() const;
 
   // Returns the textual representation of this enum attribute case.
   StringRef getStr() const;
 
   // Returns the value of this enum attribute case.
   int64_t getValue() const;

mlir/lib/TableGen/Attribute.cpp

 EnumAttrCase::EnumAttrCase(const llvm::Record *record) : Attribute(record) {
   assert(isSubClassOf("EnumAttrCaseInfo") &&
          "must be subclass of TableGen 'EnumAttrInfo' class");
 }
 
 EnumAttrCase::EnumAttrCase(const llvm::DefInit *init)
     : EnumAttrCase(init->getDef()) {}
 
-bool EnumAttrCase::isStrCase() const { return isSubClassOf("StrEnumAttrCase"); }
-
 StringRef EnumAttrCase::getSymbol() const {
   return def->getValueAsString("symbol");
 }
 
 StringRef EnumAttrCase::getStr() const { return def->getValueAsString("str"); }
 
 int64_t EnumAttrCase::getValue() const { return def->getValueAsInt("value"); }
 

mlir/test/IR/attribute.mlir

func @string_attr_custom_type() {
   // CHECK: "string_data" : !foo.string
   test.string_attr_with_type "string_data" : !foo.string
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// Test StrEnumAttr
-//===----------------------------------------------------------------------===//
-
-// CHECK-LABEL: func @allowed_cases_pass
-func @allowed_cases_pass() {
-  // CHECK: test.str_enum_attr
-  %0 = "test.str_enum_attr"() {attr = "A"} : () -> i32
-  // CHECK: test.str_enum_attr
-  %1 = "test.str_enum_attr"() {attr = "B"} : () -> i32
-  return
-}
-
-// -----
-
-func @disallowed_case_fail() {
-  // expected-error @+1 {{allowed string cases: 'A', 'B'}}
-  %0 = "test.str_enum_attr"() {attr = 7: i32} : () -> i32
-  return
-}
-
-// -----
-
-//===----------------------------------------------------------------------===//
 // Test I32EnumAttr
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: func @allowed_cases_pass
 func @allowed_cases_pass() {
   // CHECK: test.i32_enum_attr
   %0 = "test.i32_enum_attr"() {attr = 5: i32} : () -> i32
   // CHECK: test.i32_enum_attr

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

 def TypeArrayAttrWithDefaultOp : TEST_Op<"type_array_attr_with_default"> {
   let arguments = (ins DefaultValuedAttr<TypeArrayAttr, "{}">:$attr);
 }
 def TypeStringAttrWithTypeOp : TEST_Op<"string_attr_with_type"> {
   let arguments = (ins TypedStrAttr<AnyType>:$attr);
   let assemblyFormat = "$attr attr-dict";
 }
 
-def StrCaseA: StrEnumAttrCase<"A">;
-def StrCaseB: StrEnumAttrCase<"B">;
-
-def SomeStrEnum: StrEnumAttr<
-  "SomeStrEnum", "", [StrCaseA, StrCaseB]>;
-
-def StrEnumAttrOp : TEST_Op<"str_enum_attr"> {
-  let arguments = (ins SomeStrEnum:$attr);
-  let results = (outs I32:$val);
-}
-
 def I32Case5:  I32EnumAttrCase<"case5", 5>;
 def I32Case10: I32EnumAttrCase<"case10", 10>;
 
 def SomeI32Enum: I32EnumAttr<
   "SomeI32Enum", "", [I32Case5, I32Case10]>;
 
 def I32EnumAttrOp : TEST_Op<"i32_enum_attr"> {
   let arguments = (ins SomeI32Enum:$attr);
def OpAttrMatch4 : TEST_Op<"match_op_attribute4"> {
   let results = (outs I32);
 }
 def : Pat<(OpAttrMatch3 $attr), (OpAttrMatch4 ConstUnitAttr, $attr)>;
 
 // Test with constant attr.
 def OpC : TEST_Op<"op_c">, Arguments<(ins I32)>, Results<(outs I32)>;
 def : Pat<(OpC $input), (OpB $input, ConstantAttr<I32Attr, "17">:$attr)>;
 
-// Test string enum attribute in rewrites.
-def : Pat<(StrEnumAttrOp StrCaseA), (StrEnumAttrOp StrCaseB)>;
 // Test integer enum attribute in rewrites.
 def : Pat<(I32EnumAttrOp I32Case5), (I32EnumAttrOp I32Case10)>;
 def : Pat<(I64EnumAttrOp I64Case5), (I64EnumAttrOp I64Case10)>;
 
 //===----------------------------------------------------------------------===//
 // Test Patterns (Multi-result Ops)
 
 def MultiResultOpKind1: I64EnumAttrCase<"kind1", 1>;

 def : Pat<(SourceOp $val, ConstantAttr<I32Attr, "66">:$attr),
           (TwoToOne (OpX $val, (returnType $val), (location "loc1")),
                     (OpX $val, (location "loc2"), (returnType $val)))>;
 
 //===----------------------------------------------------------------------===//
 // Test Legalization
 //===----------------------------------------------------------------------===//
 
-def Test_LegalizerEnum_Success : StrEnumAttrCase<"Success">;
-def Test_LegalizerEnum_Failure : StrEnumAttrCase<"Failure">;
-
-def Test_LegalizerEnum : StrEnumAttr<"Success", "Failure",
-  [Test_LegalizerEnum_Success, Test_LegalizerEnum_Failure]>;
+def Test_LegalizerEnum_Success : ConstantStrAttr<StrAttr, "Success">;
+def Test_LegalizerEnum_Failure : ConstantStrAttr<StrAttr, "Failure">;
 
 def ILLegalOpA : TEST_Op<"illegal_op_a">, Results<(outs I32)>;
 def ILLegalOpB : TEST_Op<"illegal_op_b">, Results<(outs I32)>;
 def ILLegalOpC : TEST_Op<"illegal_op_c">, Results<(outs I32)>;
 def ILLegalOpD : TEST_Op<"illegal_op_d">, Results<(outs I32)>;
 def ILLegalOpE : TEST_Op<"illegal_op_e">, Results<(outs I32)>;
 def ILLegalOpF : TEST_Op<"illegal_op_f">, Results<(outs I32)>;
 def ILLegalOpG : TEST_Op<"illegal_op_g">, Results<(outs I32)>;
 def LegalOpA : TEST_Op<"legal_op_a">,
-  Arguments<(ins Test_LegalizerEnum:$status)>, Results<(outs I32)>;
+  Arguments<(ins StrAttr:$status)>, Results<(outs I32)>;
 def LegalOpB : TEST_Op<"legal_op_b">, Results<(outs I32)>;
 def LegalOpC : TEST_Op<"legal_op_c">,
   Arguments<(ins I32)>, Results<(outs I32)>;
 
 // Check that the conversion infrastructure can properly undo the creation of
 // operations where an operation was created before its parent, in this case,
 // in the parent's builder.
 def IllegalOpTerminator : TEST_Op<"illegal_op_terminator", [Terminator]>;

mlir/test/mlir-tblgen/pattern.mlir

 }
 
 
 
 //===----------------------------------------------------------------------===//
 // Test Enum Attributes
 //===----------------------------------------------------------------------===//
 
-// CHECK-LABEL: verifyStrEnumAttr
-func @verifyStrEnumAttr() -> i32 {
-  // CHECK: "test.str_enum_attr"() {attr = "B"}
-  %0 = "test.str_enum_attr"() {attr = "A"} : () -> i32
-  return %0 : i32
-}
-
 // CHECK-LABEL: verifyI32EnumAttr
 func @verifyI32EnumAttr() -> i32 {
   // CHECK: "test.i32_enum_attr"() {attr = 10 : i32}
   %0 = "test.i32_enum_attr"() {attr = 5: i32} : () -> i32
   return %0 : i32
 }
 
 // CHECK-LABEL: verifyI64EnumAttr

mlir/tools/mlir-tblgen/DirectiveCommonGen.cpp

 // engineering to keep the common information in a single place to avoid
 // duplication, reduce engineering effort and prevent mistakes.
 // Currently that common place is llvm/include/llvm/Frontend/OpenMP/OMP.td for
 // OpenMP and llvm/include/llvm/Frontend/OpenACC/ACC.td for OpenACC.
 // We plan to use this tablegen source to generate all the required
 // declarations, functions etc.
 //
 // Some OpenMP/OpenACC clauses accept only a fixed set of values as inputs.
-// These can be represented as a String Enum Attribute (StrEnumAttr) in MLIR
+// These can be represented as a Enum Attributes (EnumAttrDef) in MLIR
 // ODS. The emitDecls function below currently generates these enumerations. The
 // name of the enumeration is specified in the enumClauseValue field of
 // Clause record in OMP.td. This name can be used to specify the type of the
 // OpenMP operation's operand. The allowedClauseValues field provides the list
 // of ClauseValues which are part of the enumeration.
 static bool emitDecls(const RecordKeeper &recordKeeper, llvm::StringRef dialect,
                       raw_ostream &os) {
   // A dialect must be selected for the generated attributes.

mlir/tools/mlir-tblgen/EnumsGen.cpp

static void emitUnderlyingToSymFnForIntEnum(const Record &enumDef,
   os << "  default: return ::llvm::None;\n"
      << "  }\n"
      << "}\n\n";
 }
 
 static void emitSpecializedAttrDef(const Record &enumDef, raw_ostream &os) {
   EnumAttr enumAttr(enumDef);
   StringRef enumName = enumAttr.getEnumClassName();
-  StringRef symToStrFnName = enumAttr.getSymbolToStringFnName();
-  StringRef strToSymFnName = enumAttr.getStringToSymbolFnName();
   StringRef attrClassName = enumAttr.getSpecializedAttrClassName();
   llvm::Record *baseAttrDef = enumAttr.getBaseAttrClass();
   Attribute baseAttr(baseAttrDef);
 
   // Emit classof method
 
   os << formatv("bool {0}::classof(::mlir::Attribute attr) {{\n",
                 attrClassName);
static void emitSpecializedAttrDef(const Record &enumDef, raw_ostream &os) {
 
   os << "}\n";
 
   // Emit get method
 
   os << formatv("{0} {0}::get(::mlir::MLIRContext *context, {1} val) {{\n",
                 attrClassName, enumName);
 
-  if (enumAttr.isSubClassOf("StrEnumAttr")) {
-    os << formatv("  ::mlir::StringAttr baseAttr = "
-                  "::mlir::StringAttr::get(context, {0}(val));\n",
-                  symToStrFnName);
-  } else {
-    StringRef underlyingType = enumAttr.getUnderlyingType();
 
-    // Assuming that it is IntegerAttr constraint
-    int64_t bitwidth = 64;
-    if (baseAttrDef->getValue("valueType")) {
-      auto *valueTypeDef = baseAttrDef->getValueAsDef("valueType");
-      if (valueTypeDef->getValue("bitwidth"))
-        bitwidth = valueTypeDef->getValueAsInt("bitwidth");
-    }
 
-    os << formatv("  ::mlir::IntegerType intType = "
-                  "::mlir::IntegerType::get(context, {0});\n",
-                  bitwidth);
-    os << formatv("  ::mlir::IntegerAttr baseAttr = "
-                  "::mlir::IntegerAttr::get(intType, static_cast<{0}>(val));\n",
-                  underlyingType);
-  }
   os << formatv("  return baseAttr.cast<{0}>();\n", attrClassName);
 
   os << "}\n";
 
   // Emit getValue method
 
   os << formatv("{0} {1}::getValue() const {{\n", enumName, attrClassName);
 
-  if (enumAttr.isSubClassOf("StrEnumAttr")) {
-    os << formatv("  const auto res = {0}(::mlir::StringAttr::getValue());\n",
-                  strToSymFnName);
-    os << "  return res.getValue();\n";
-  } else {
-    os << formatv("  return static_cast<{0}>(::mlir::IntegerAttr::getInt());\n",
-                  enumName);
-  }
 
   os << "}\n";
 }
 
 static void emitUnderlyingToSymFnForBitEnum(const Record &enumDef,
                                             raw_ostream &os) {
   EnumAttr enumAttr(enumDef);
   StringRef enumName = enumAttr.getEnumClassName();
public:
   using ::mlir::{2}::{2};
   static bool classof(::mlir::Attribute attr);
   static {1} get(::mlir::MLIRContext *context, {0} val);
   {0} getValue() const;
 };
 )";
   if (enumAttr.genSpecializedAttr()) {
     StringRef attrClassName = enumAttr.getSpecializedAttrClassName();
-    StringRef baseAttrClassName =
-        enumAttr.isSubClassOf("StrEnumAttr") ? "StringAttr" : "IntegerAttr";
+    StringRef baseAttrClassName = "IntegerAttr";
     os << formatv(attrClassDecl, enumName, attrClassName, baseAttrClassName);
   }
 
   for (auto ns : llvm::reverse(namespaces))
     os << "} // namespace " << ns << "\n";
 
   // Emit DenseMapInfo for this enum class
   emitDenseMapInfo(enumName, underlyingType, cppNamespace, os);

mlir/tools/mlir-tblgen/OpFormatGen.cpp

static void genEnumAttrPrinter(const NamedAttribute *var, const Operator &op,
   body << llvm::formatv(enumAttrBeginPrinterCode,
                         (var->attr.isOptional() ? "*" : "") +
                             op.getGetterName(var->name),
                         enumAttr.getSymbolToStringFnName());
 
   // Get a string containing all of the cases that can't be represented with a
   // keyword.
   BitVector nonKeywordCases(cases.size());
-  bool hasStrCase = false;
   for (auto &it : llvm::enumerate(cases)) {
-    hasStrCase = it.value().isStrCase();
     if (!canFormatStringAsKeyword(it.value().getStr()))
       nonKeywordCases.set(it.index());
   }
 
-  // If this is a string enum, use the case string to determine which cases
-  // 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"
-              "      _odsPrinter << '\"' << caseValueStr << '\"';\n"
-              "    else\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()) {
     for (auto &it : llvm::enumerate(cases)) {
       int64_t value = it.value().getValue();
       if (value < 0 || !llvm::isPowerOf2_64(value))
         nonKeywordCases.set(it.index());

mlir/tools/mlir-tblgen/RewriterGen.cpp

if (leaf.isStringAttr())
     PrintFatalError(loc, "raw string not supported as argument");
   if (leaf.isConstantAttr()) {
     auto constAttr = leaf.getAsConstantAttr();
     return handleConstantAttr(constAttr.getAttribute(),
                               constAttr.getConstantValue());
   }
   if (leaf.isEnumAttrCase()) {
     auto enumCase = leaf.getAsEnumAttrCase();
-    if (enumCase.isStrCase())
-      return handleConstantAttr(enumCase, "\"" + enumCase.getSymbol() + "\"");
     // This is an enum case backed by an IntegerAttr. We need to get its value
     // to build the constant.
     std::string val = std::to_string(enumCase.getValue());
     return handleConstantAttr(enumCase, val);
   }
 
   LLVM_DEBUG(llvm::dbgs() << "handle argument '" << patArgName << "'\n");
   auto argName = symbolInfoMap.getValueAndRangeUse(patArgName);

mlir/unittests/TableGen/EnumsGenTest.cpp

 /// Pull in generated enum utility declarations and definitions.
 #include "EnumsGenTest.h.inc"
 
 #include "EnumsGenTest.cpp.inc"
 
 /// Test namespaces and enum class/utility names.
 using Outer::Inner::ConvertToEnum;
 using Outer::Inner::ConvertToString;
-using Outer::Inner::StrEnum;
-using Outer::Inner::StrEnumAttr;
+using Outer::Inner::FooEnum;
+using Outer::Inner::FooEnumAttr;
 
 TEST(EnumsGenTest, GeneratedStrEnumDefinition) {
-  EXPECT_EQ(0u, static_cast<uint64_t>(StrEnum::CaseA));
-  EXPECT_EQ(10u, static_cast<uint64_t>(StrEnum::CaseB));
+  EXPECT_EQ(0u, static_cast<uint64_t>(FooEnum::CaseA));
+  EXPECT_EQ(1u, static_cast<uint64_t>(FooEnum::CaseB));
 }
 
 TEST(EnumsGenTest, GeneratedI32EnumDefinition) {
   EXPECT_EQ(5u, static_cast<uint64_t>(I32Enum::Case5));
   EXPECT_EQ(10u, static_cast<uint64_t>(I32Enum::Case10));
 }
 
 TEST(EnumsGenTest, GeneratedDenseMapInfo) {
-  llvm::DenseMap<StrEnum, std::string> myMap;
+  llvm::DenseMap<FooEnum, std::string> myMap;
 
-  myMap[StrEnum::CaseA] = "zero";
-  myMap[StrEnum::CaseB] = "one";
+  myMap[FooEnum::CaseA] = "zero";
+  myMap[FooEnum::CaseB] = "one";
 
-  EXPECT_EQ(myMap[StrEnum::CaseA], "zero");
-  EXPECT_EQ(myMap[StrEnum::CaseB], "one");
+  EXPECT_EQ(myMap[FooEnum::CaseA], "zero");
+  EXPECT_EQ(myMap[FooEnum::CaseB], "one");
 }
 
 TEST(EnumsGenTest, GeneratedSymbolToStringFn) {
-  EXPECT_EQ(ConvertToString(StrEnum::CaseA), "CaseA");
-  EXPECT_EQ(ConvertToString(StrEnum::CaseB), "CaseB");
+  EXPECT_EQ(ConvertToString(FooEnum::CaseA), "CaseA");
+  EXPECT_EQ(ConvertToString(FooEnum::CaseB), "CaseB");
 }
 
 TEST(EnumsGenTest, GeneratedStringToSymbolFn) {
-  EXPECT_EQ(llvm::Optional<StrEnum>(StrEnum::CaseA), ConvertToEnum("CaseA"));
-  EXPECT_EQ(llvm::Optional<StrEnum>(StrEnum::CaseB), ConvertToEnum("CaseB"));
+  EXPECT_EQ(llvm::Optional<FooEnum>(FooEnum::CaseA), ConvertToEnum("CaseA"));
+  EXPECT_EQ(llvm::Optional<FooEnum>(FooEnum::CaseB), ConvertToEnum("CaseB"));
   EXPECT_EQ(llvm::None, ConvertToEnum("X"));
 }
 
 TEST(EnumsGenTest, GeneratedUnderlyingType) {
   bool v = std::is_same<uint32_t, std::underlying_type<I32Enum>::type>::value;
   EXPECT_TRUE(v);
 }
 
TEST(EnumsGenTest, GeneratedIntAttributeClass) {
   EXPECT_EQ(enumAttr.getValue(), rawVal);
 
   mlir::Type intType = mlir::IntegerType::get(&ctx, 32);
   mlir::Attribute intAttr = mlir::IntegerAttr::get(intType, 5);
   EXPECT_TRUE(intAttr.isa<I32EnumAttr>());
   EXPECT_EQ(intAttr, enumAttr);
 }
 
-TEST(EnumsGenTest, GeneratedStringAttributeClass) {
-  mlir::MLIRContext ctx;
-  StrEnum rawVal = StrEnum::CaseA;
-
-  StrEnumAttr enumAttr = StrEnumAttr::get(&ctx, rawVal);
-  EXPECT_NE(enumAttr, nullptr);
-  EXPECT_EQ(enumAttr.getValue(), rawVal);
-
-  mlir::Attribute strAttr = mlir::StringAttr::get(&ctx, "CaseA");
-  EXPECT_TRUE(strAttr.isa<StrEnumAttr>());
-  EXPECT_EQ(strAttr, enumAttr);
-}
-
 TEST(EnumsGenTest, GeneratedBitAttributeClass) {
   mlir::MLIRContext ctx;
 
   mlir::Type intType = mlir::IntegerType::get(&ctx, 32);
   mlir::Attribute intAttr = mlir::IntegerAttr::get(
       intType,
       static_cast<uint32_t>(BitEnumWithNone::Bit0 | BitEnumWithNone::Bit3));
   EXPECT_TRUE(intAttr.isa<BitEnumWithNoneAttr>());
   EXPECT_TRUE(intAttr.isa<BitEnumWithoutNoneAttr>());
 
   intAttr = mlir::IntegerAttr::get(
       intType, static_cast<uint32_t>(BitEnumWithGroup::Bits0To3) | (1u << 6));
   EXPECT_FALSE(intAttr.isa<BitEnumWithGroupAttr>());
 }

mlir/unittests/TableGen/enums.td

 //===-- enums.td - EnumsGen test definition file -----------*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 include "mlir/IR/OpBase.td"
 
-def CaseA: StrEnumAttrCase<"CaseA">;
-def CaseB: StrEnumAttrCase<"CaseB", 10>;
+def CaseA: I32EnumAttrCase<"CaseA", 0>;
+def CaseB: I32EnumAttrCase<"CaseB", 1>;
 
-def StrEnum: StrEnumAttr<"StrEnum", "A test enum", [CaseA, CaseB]> {
+def FooEnum: I32EnumAttr<"FooEnum", "A test enum", [CaseA, CaseB]> {
   let cppNamespace = "Outer::Inner";
   let stringToSymbolFnName = "ConvertToEnum";
   let symbolToStringFnName = "ConvertToString";
   let genSpecializedAttr = 1;
 }
 
 def Case5: I32EnumAttrCase<"Case5", 5>;
 def Case10: I32EnumAttrCase<"Case10", 10>;