[mlir] Move tblgen code generation to use functional forms of cast/isa

[tpopp]

Summary

The method forms are deprecated. This updates the rest of the tblgen
uses of methods where a function call is available.

Context:

• https://mlir.llvm.org/deprecation/ at "Use the free function variants for dyn_cast/cast/isa/…"
• Original discussion at https://discourse.llvm.org/t/preferred-casting-style-going-forward/68443

mlir/test/mlir-linalg-ods-gen/test-linalg-ods-yaml-gen.yaml

 
 
 # IMPL-LABEL:  void Test1Op::regionBuilder(ImplicitLocOpBuilder &b,
 #  IMPL-NEXT:    Block &block, ArrayRef<NamedAttribute> attrs)
 #       IMPL:  TypeFn castVal = TypeFn::cast_signed;
 #  IMPL-NEXT:  auto castIter = llvm::find_if(attrs, [&](const NamedAttribute &attr) {
 #  IMPL-NEXT:                                return attr.getName() == "cast"; });
 #  IMPL-NEXT:  if (castIter != attrs.end()) {
-#  IMPL-NEXT:    if (auto attr = castIter->getValue().dyn_cast<TypeFnAttr>())
+#  IMPL-NEXT:    if (auto attr = llvm::dyn_cast<TypeFnAttr>(castIter->getValue()))
 #  IMPL-NEXT:      castVal = attr.getValue();
 #  IMPL-NEXT:  }
 
 #       IMPL:  Value [[VAL0:[a-z0-9]+]] = helper.constant("42 : i64");
 #   IMPL-DAG:  Value [[VAL1:[a-z0-9]+]] = helper.buildTypeFn(castVal, block.getArgument(0).getType(), [[VAL0]]);
 #   IMPL-DAG:  Value [[VAL2:[a-z0-9]+]] = helper.index(1);
 #   IMPL-DAG:  Value [[VAL3:[a-z0-9]+]] = helper.buildTypeFn(castVal, block.getArgument(0).getType(), [[VAL2]]);
 #   IMPL-DAG:  Value [[VAL4:[a-z0-9]+]] = helper.buildBinaryFn(BinaryFn::add, [[VAL1]], [[VAL3]]);

mlir/test/mlir-tblgen/attr-or-type-format.td

def AttrC : TestAttr<"TestF"> {
   let mnemonic = "attr_c";
   let assemblyFormat = "params";
 }
 
 /// Test attribute with self type parameter
 
 // ATTR-LABEL: Attribute TestGAttr::parse
 // ATTR: if (odsType)
-// ATTR:   if (auto reqType = odsType.dyn_cast<::mlir::Type>())
+// ATTR:   if (auto reqType = ::llvm::dyn_cast<::mlir::Type>(odsType))
 // ATTR:     _result_type = reqType
 // ATTR: TestGAttr::get
 // ATTR-NEXT: *_result_a
 // ATTR-NEXT: _result_type.value_or(::mlir::NoneType::get(
 def AttrD : TestAttr<"TestG"> {
   let parameters = (ins "int":$a, AttributeSelfTypeParameter<"">:$type);
   let mnemonic = "attr_d";
   let assemblyFormat = "$a";

mlir/test/mlir-tblgen/op-attribute.td

 // DEF-NEXT:   return emitError(loc, "'test.a_op' op ""attribute 'cAttr' failed to satisfy constraint: some attribute kind");
 // DEF:      if (tblgen_dAttr && !((some-condition)))
 // DEF-NEXT:   return emitError(loc, "'test.a_op' op ""attribute 'dAttr' failed to satisfy constraint: some attribute kind");
 
 // Test getter methods
 // ---
 
 // DEF:      some-attr-kind AOp::getAAttrAttr()
-// DEF-NEXT:   ::mlir::impl::getAttrFromSortedRange((*this)->getAttrs().begin() + 0, (*this)->getAttrs().end() - 0, getAAttrAttrName()).cast<some-attr-kind>()
+// DEF-NEXT:   ::llvm::cast<some-attr-kind>(::mlir::impl::getAttrFromSortedRange((*this)->getAttrs().begin() + 0, (*this)->getAttrs().end() - 0, getAAttrAttrName()))
 // DEF:      some-return-type AOp::getAAttr() {
 // DEF-NEXT:   auto attr = getAAttrAttr()
 // DEF-NEXT:   return attr.some-convert-from-storage();
 
 // DEF:      some-attr-kind AOp::getBAttrAttr()
-// DEF-NEXT:   ::mlir::impl::getAttrFromSortedRange((*this)->getAttrs().begin() + 1, (*this)->getAttrs().end() - 0, getBAttrAttrName()).dyn_cast_or_null<some-attr-kind>()
+// DEF-NEXT:   ::llvm::dyn_cast_or_null<some-attr-kind>(::mlir::impl::getAttrFromSortedRange((*this)->getAttrs().begin() + 1, (*this)->getAttrs().end() - 0, getBAttrAttrName()))
 // DEF:      some-return-type AOp::getBAttr() {
 // DEF-NEXT:   auto attr = getBAttrAttr();
 // DEF-NEXT:   return attr.some-convert-from-storage();
 
 // DEF:      some-attr-kind AOp::getCAttrAttr()
-// DEF-NEXT:   ::mlir::impl::getAttrFromSortedRange((*this)->getAttrs().begin() + 1, (*this)->getAttrs().end() - 0, getCAttrAttrName()).dyn_cast_or_null<some-attr-kind>()
+// DEF-NEXT:   ::llvm::dyn_cast_or_null<some-attr-kind>(::mlir::impl::getAttrFromSortedRange((*this)->getAttrs().begin() + 1, (*this)->getAttrs().end() - 0, getCAttrAttrName()))
 // DEF:      ::std::optional<some-return-type> AOp::getCAttr() {
 // DEF-NEXT:   auto attr = getCAttrAttr()
 // DEF-NEXT:   return attr ? ::std::optional<some-return-type>(attr.some-convert-from-storage()) : (::std::nullopt);
 
 // DEF:      some-attr-kind AOp::getDAttrAttr()
-// DEF-NEXT:   ::mlir::impl::getAttrFromSortedRange((*this)->getAttrs().begin() + 1, (*this)->getAttrs().end() - 0, getDAttrAttrName()).dyn_cast_or_null<some-attr-kind>()
+// DEF-NEXT:   ::llvm::dyn_cast_or_null<some-attr-kind>(::mlir::impl::getAttrFromSortedRange((*this)->getAttrs().begin() + 1, (*this)->getAttrs().end() - 0, getDAttrAttrName()))
 // DEF:      some-return-type AOp::getDAttr() {
 // DEF-NEXT:   auto attr = getDAttrAttr();
 // DEF-NEXT:   if (!attr)
 // DEF-NEXT:       return some-const-builder-call(::mlir::Builder((*this)->getContext()), 4.2).some-convert-from-storage();
 // DEF-NEXT:   return attr.some-convert-from-storage();
 
 // Test setter methods
 // ---

 // DEF-NEXT:   return emitError(loc, "'test2.a_get_op' op ""attribute 'bAttr' failed to satisfy constraint: some attribute kind");
 // DEF:      if (tblgen_cAttr && !((some-condition)))
 // DEF-NEXT:   return emitError(loc, "'test2.a_get_op' op ""attribute 'cAttr' failed to satisfy constraint: some attribute kind");
 
 // Test getter methods
 // ---
 
 // DEF:      some-attr-kind AgetOp::getAAttrAttr()
-// DEF-NEXT:   ::mlir::impl::getAttrFromSortedRange({{.*}}).cast<some-attr-kind>()
+// DEF-NEXT:   ::llvm::cast<some-attr-kind>(::mlir::impl::getAttrFromSortedRange({{.*}}))
 // DEF:      some-return-type AgetOp::getAAttr() {
 // DEF-NEXT:   auto attr = getAAttrAttr()
 // DEF-NEXT:   return attr.some-convert-from-storage();
 
 // DEF:      some-attr-kind AgetOp::getBAttrAttr()
-// DEF-NEXT:   return ::mlir::impl::getAttrFromSortedRange({{.*}}).dyn_cast_or_null<some-attr-kind>()
+// DEF-NEXT:   return ::llvm::dyn_cast_or_null<some-attr-kind>(::mlir::impl::getAttrFromSortedRange({{.*}}))
 // DEF:      some-return-type AgetOp::getBAttr() {
 // DEF-NEXT:   auto attr = getBAttrAttr();
 // DEF-NEXT:   if (!attr)
 // DEF-NEXT:       return some-const-builder-call(::mlir::Builder((*this)->getContext()), 4.2).some-convert-from-storage();
 // DEF-NEXT:   return attr.some-convert-from-storage();
 
 // DEF:      some-attr-kind AgetOp::getCAttrAttr()
-// DEF-NEXT:   return ::mlir::impl::getAttrFromSortedRange({{.*}}).dyn_cast_or_null<some-attr-kind>()
+// DEF-NEXT:   return ::llvm::dyn_cast_or_null<some-attr-kind>(::mlir::impl::getAttrFromSortedRange({{.*}}))
 // DEF:      ::std::optional<some-return-type> AgetOp::getCAttr() {
 // DEF-NEXT:   auto attr = getCAttrAttr()
 // DEF-NEXT:   return attr ? ::std::optional<some-return-type>(attr.some-convert-from-storage()) : (::std::nullopt);
 
 // Test setter methods
 // ---
 
 // DEF:      void AgetOp::setAAttrAttr(some-attr-kind attr) {

mlir/test/mlir-tblgen/op-result.td

 def IntegerTypeAttr : TypeAttrBase<"IntegerType", "Integer type attribute">;
 def OpD : NS_Op<"type_attr_as_result_type", [FirstAttrDerivedResultType]> {
   let arguments = (ins I32:$x, IntegerTypeAttr:$attr, F32Attr:$f32);
   let results = (outs AnyTensor:$y);
 }
 
 // CHECK-LABEL: OpD definitions
 // CHECK: void OpD::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes)
-// CHECK: odsState.addTypes({attr.getValue().cast<::mlir::TypeAttr>().getValue()});
+// CHECK: odsState.addTypes({::llvm::cast<::mlir::TypeAttr>(attr.getValue()).getValue()});
 
 def OpE : NS_Op<"value_attr_as_result_type", [FirstAttrDerivedResultType]> {
   let arguments = (ins I32:$x, F32Attr:$attr);
   let results = (outs AnyTensor:$y);
 }
 
 // CHECK-LABEL: OpE definitions
 // CHECK: void OpE::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes)
-// CHECK: odsState.addTypes({attr.getValue().cast<::mlir::TypedAttr>().getType()});
+// CHECK: odsState.addTypes({::llvm::cast<::mlir::TypedAttr>(attr.getValue()).getType()});
 
 def OpF : NS_Op<"one_variadic_result_op", []> {
   let results = (outs Variadic<I32>:$x);
 }
 
 // CHECK-LABEL: void OpF::build
 // CHECK-SAME:    ::mlir::TypeRange x
 // CHECK-NOT:     assert

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp

 static std::string generateCppExpression(SerializedAffineMap self,
                                          StringRef contextName) {
   std::string printedStr;
   llvm::raw_string_ostream printedSs(printedStr);
   self.affineMapAttr.print(printedSs);
   printedSs.flush();
 
   static const char exprFormat[] =
-      R"FMT(mlir::parseAttribute("{0}", {1}).cast<AffineMapAttr>().getValue())FMT";
+      R"FMT(llvm::cast<AffineMapAttr>(mlir::parseAttribute("{0}", {1})).getValue())FMT";
   return llvm::formatv(exprFormat, printedStr, contextName);
 }
 
 template <typename Container>
 static std::string interleaveToString(Container &container,
                                       StringRef separator) {
   std::string result;
   llvm::raw_string_ostream ss(result);
for (LinalgOperandDef &arg : args) {
       // {0}: enum name
       // {1}: attribute name
       // {2}: default type function name
       static const char attrDef[] = R"FMT(
 {0} {1}Val = {0}::{2};
 auto {1}Iter = llvm::find_if(attrs, [&](const NamedAttribute &attr) {{
                               return attr.getName() == "{1}"; });
 if ({1}Iter != attrs.end()) {{
-  if (auto attr = {1}Iter->getValue().dyn_cast<{0}Attr>())
+  if (auto attr = llvm::dyn_cast<{0}Attr>({1}Iter->getValue()))
     {1}Val = attr.getValue();
 }
 )FMT";
       std::string enumName = convertOperandKindToEnumName(arg.kind);
       attrs.push_back(
           llvm::formatv(attrDef, enumName, arg.name, arg.defaultFn));
     }
     for (LinalgOperandDef &arg : args) {

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

static void genAttrSelfTypeParser(MethodBody &os, const FmtContext &ctx,
                                   const AttributeSelfTypeParameter &param) {
   // "Parser" for an attribute self type parameter that checks the
   // optionally-parsed trailing colon type.
   //
   // $0: The C++ storage class of the type parameter.
   // $1: The self type parameter name.
   const char *const selfTypeParser = R"(
 if ($_type) {
-  if (auto reqType = $_type.dyn_cast<$0>()) {
+  if (auto reqType = ::llvm::dyn_cast<$0>($_type)) {
     _result_$1 = reqType;
   } else {
     $_parser.emitError($_loc, "invalid kind of type specified");
     return {};
   }
 })";
 
   // If the attribute self type parameter is required, emit code that emits an

mlir/tools/mlir-tblgen/EnumsGen.cpp

static void emitSpecializedAttrDef(const Record &enumDef, raw_ostream &os) {
   }
 
   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 << formatv("  return ::llvm::cast<{0}>(baseAttr);\n", attrClassName);
 
   os << "}\n";
 
   // Emit getValue method
 
   os << formatv("{0} {1}::getValue() const {{\n", enumName, attrClassName);
 
   os << formatv("  return static_cast<{0}>(::mlir::IntegerAttr::getInt());\n",

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

for (unsigned i = 0; i < index; ++i)
     start += sizeAttr[i];
   return {start, sizeAttr[index]};
 )";
 /// The code snippet to initialize the sizes for the value range calculation.
 ///
 /// {0}: The code to get the attribute.
 static const char *const adapterSegmentSizeAttrInitCode = R"(
   assert({0} && "missing segment size attribute for op");
-  auto sizeAttr = {0}.cast<::mlir::DenseI32ArrayAttr>();
+  auto sizeAttr = ::llvm::cast<::mlir::DenseI32ArrayAttr>({0});
 )";
 /// The code snippet to initialize the sizes for the value range calculation.
 ///
 /// {0}: The code to get the attribute.
 static const char *const opSegmentSizeAttrInitCode = R"(
-  auto sizeAttr = {0}.cast<::mlir::DenseI32ArrayAttr>();
+  auto sizeAttr = ::llvm::cast<::mlir::DenseI32ArrayAttr>({0});
 )";
 
 /// The logic to calculate the actual value range for a declared operand
 /// of an op with variadic of variadic operands within the OpAdaptor.
 ///
 /// {0}: The name of the segment attribute.
 /// {1}: The index of the main operand.
 /// {2}: The range type of adaptor.
static void genNativeTraitAttrVerifier(MethodBody &body,
   // expected number of elements.
   //
   // {0}: Attribute name.
   // {1}: Expected number of elements.
   // {2}: "operand" or "result".
   // {3}: Emit error prefix.
   const char *const checkAttrSizedValueSegmentsCode = R"(
   {
-    auto sizeAttr = tblgen_{0}.cast<::mlir::DenseI32ArrayAttr>();
+    auto sizeAttr = ::llvm::cast<::mlir::DenseI32ArrayAttr>(tblgen_{0});
     auto numElements = sizeAttr.asArrayRef().size();
     if (numElements != {1})
       return {3}"'{0}' attribute for specifying {2} segments must have {1} "
                 "elements, but got ") << numElements;
   }
   )";
 
   // Verify a few traits first so that we can use getODSOperands() and
if (!dict) {
     if (diag)
       *diag << "expected DictionaryAttr to set properties";
     return failure();
   }
     )decl";
   // TODO: properties might be optional as well.
   const char *propFromAttrFmt = R"decl(;
     {{
-      auto setFromAttr = [] (auto &propStorage, ::mlir::Attribute propAttr, 
+      auto setFromAttr = [] (auto &propStorage, ::mlir::Attribute propAttr,
                              ::mlir::InFlightDiagnostic *propDiag) {{
         {0};
       };
       auto attr = dict.get("{1}");
       if (!attr) {{
         if (diag)
           *diag << "expected key entry for {1} in DictionaryAttr to set "
                    "Properties.";
getPropMethod << formatv(R"decl(
                                        propStorage));
     }
 )decl",
                              name);
   }
   getPropMethod << R"decl(
   if (!attrs.empty())
     return odsBuilder.getDictionaryAttr(attrs);
-  return {};    
+  return {};
 )decl";
 
   // Hashing for the property
 
   const char *propHashFmt = R"decl(
   auto hash_{0} = [] (const auto &propStorage) -> llvm::hash_code {
     return {1};
   };
void OpEmitter::genAttrGetters() {
   // class that allows referring to the attributes via accessors instead of
   // having to use the string interface for better compile time verification.
   auto emitAttrWithStorageType = [&](StringRef name, StringRef attrName,
                                      Attribute attr) {
     auto *method = opClass.addMethod(attr.getStorageType(), name + "Attr");
     if (!method)
       return;
     method->body() << formatv(
-        "  return {0}.{1}<{2}>();", emitHelper.getAttr(attrName),
+        "  return ::llvm::{1}<{2}>({0});", emitHelper.getAttr(attrName),
         attr.isOptional() || attr.hasDefaultValue() ? "dyn_cast_or_null"
                                                     : "cast",
         attr.getStorageType());
   };
 
   for (const NamedAttribute &namedAttr : op.getAttributes()) {
     std::string name = op.getGetterName(namedAttr.name);
     if (namedAttr.attr.isDerivedAttr()) {
void OpEmitter::genUseAttrAsResultTypeBuilder() {
   const auto &namedAttr = op.getAttribute(0);
 
   body << "  auto attrName = " << op.getGetterName(namedAttr.name)
        << "AttrName(" << builderOpState
        << ".name);\n"
           "  for (auto attr : attributes) {\n"
           "    if (attr.getName() != attrName) continue;\n";
   if (namedAttr.attr.isTypeAttr()) {
-    resultType = "attr.getValue().cast<::mlir::TypeAttr>().getValue()";
+    resultType = "::llvm::cast<::mlir::TypeAttr>(attr.getValue()).getValue()";
   } else {
-    resultType = "attr.getValue().cast<::mlir::TypedAttr>().getType()";
+    resultType = "::llvm::cast<::mlir::TypedAttr>(attr.getValue()).getType()";
   }
 
   // Operands
   body << "  " << builderOpState << ".addOperands(operands);\n";
 
   // Attributes
   body << "  " << builderOpState << ".addAttributes(attributes);\n";
 
for (int i = 0, e = op.getNumResults(); i != e; ++i) {
         } else {
           auto *attr =
               op.getArg(arg.operandOrAttributeIndex()).get<NamedAttribute *>();
           body << "  ::mlir::TypedAttr odsInferredTypeAttr" << inferredTypeIdx
                << " = ";
           if (op.getDialect().usePropertiesForAttributes()) {
             body << "(properties ? properties.as<Properties *>()->"
                  << attr->name
-                 << " : attributes.get(\"" + attr->name +
-                        "\").dyn_cast_or_null<::mlir::TypedAttr>());\n";
-          } else {
-            body << "attributes.get(\"" + attr->name +
-                        "\").dyn_cast_or_null<::mlir::TypedAttr>();\n";
+                 << " : "
+                    "::llvm::dyn_cast_or_null<::mlir::TypedAttr>(attributes."
+                    "get(\"" +
+                        attr->name + "\")));\n";
+          } else {
+            body << "::llvm::dyn_cast_or_null<::mlir::TypedAttr>(attributes."
+                    "get(\"" +
+                        attr->name + "\"));\n";
           }
           body << "  if (!odsInferredTypeAttr" << inferredTypeIdx
                << ") return ::mlir::failure();\n";
           typeStr =
               ("odsInferredTypeAttr" + Twine(inferredTypeIdx) + ".getType()")
                   .str();
         }
       } else if (std::optional<StringRef> builder =
)decl";
       os << "    using " << name << "Ty = " << storageType << ";\n"
          << "    " << name << "Ty " << name << ";\n";
 
       // Emit accessors using the interface type.
       if (attr) {
         const char *accessorFmt = R"decl(
     auto get{0}() {
       auto &propStorage = this->{1};
-      return propStorage.{2}<{3}>();
+      return ::llvm::{2}<{3}>(propStorage);
     }
     void set{0}(const {3} &propValue) {
       this->{1} = propValue;
     }
 )decl";
         os << formatv(accessorFmt, camelName, name,
                       attr->isOptional() || attr->hasDefaultValue()
                           ? "dyn_cast_or_null"
auto emitAttrWithStorageType = [&](StringRef name, StringRef emitName,
                                      Attribute attr) {
     auto *method =
         genericAdaptorBase.addMethod(attr.getStorageType(), emitName + "Attr");
     ERROR_IF_PRUNED(method, "Adaptor::" + emitName + "Attr", op);
     auto &body = method->body().indent();
     if (!useProperties)
       body << "assert(odsAttrs && \"no attributes when constructing "
               "adapter\");\n";
-    body << formatv("auto attr = {0}.{1}<{2}>();\n", emitHelper.getAttr(name),
-                    attr.hasDefaultValue() || attr.isOptional()
-                        ? "dyn_cast_or_null"
+    body << formatv(
+        "auto attr = ::llvm::{1}<{2}>({0});\n", emitHelper.getAttr(name),
+        attr.hasDefaultValue() || attr.isOptional() ? "dyn_cast_or_null"
                                                     : "cast",
-                    attr.getStorageType());
 
     if (attr.hasDefaultValue() && attr.isOptional()) {
       // Use the default value if attribute is not set.
       // TODO: this is inefficient, we are recreating the attribute for every
       // call. This should be set instead.
       std::string defaultValue = std::string(
           tgfmt(attr.getConstBuilderTemplate(), &fctx, attr.getDefaultValue()));
       body << "if (!attr)\n  attr = " << defaultValue << ";\n";

mlir/tools/mlir-tblgen/OpFormatGen.cpp

if (var && !var->isVariadicOfVariadic() && !var->isVariadic() &&
       if (dir->shouldBeQualified()) {
         body << "   _odsPrinter << " << op.getGetterName(var->name)
              << "().getType();\n";
         return;
       }
       body << "  {\n"
            << "    auto type = " << op.getGetterName(var->name)
            << "().getType();\n"
-           << "    if (auto validType = type.dyn_cast<" << cppClass << ">())\n"
+           << "    if (auto validType = ::llvm::dyn_cast<" << cppClass
+           << ">(type))\n"
            << "      _odsPrinter.printStrippedAttrOrType(validType);\n"
            << "   else\n"
            << "     _odsPrinter << type;\n"
            << "  }\n";
       return;
     }
     body << "  _odsPrinter << ";
     genTypeOperandPrinter(dir->getArg(), op, body, /*useArrayRef=*/false)

mlir/tools/mlir-tblgen/OpInterfacesGen.cpp

 /// A specialized generator for attribute interfaces.
 struct AttrInterfaceGenerator : public InterfaceGenerator {
   AttrInterfaceGenerator(const llvm::RecordKeeper &records, raw_ostream &os)
       : InterfaceGenerator(getAllInterfaceDefinitions(records, "Attr"), os) {
     valueType = "::mlir::Attribute";
     interfaceBaseType = "AttributeInterface";
     valueTemplate = "ConcreteAttr";
     substVar = "_attr";
-    StringRef castCode = "(tablegen_opaque_val.cast<ConcreteAttr>())";
+    StringRef castCode = "(::llvm::cast<ConcreteAttr>(tablegen_opaque_val))";
     nonStaticMethodFmt.addSubst(substVar, castCode).withSelf(castCode);
     traitMethodFmt.addSubst(substVar,
                             "(*static_cast<const ConcreteAttr *>(this))");
     extraDeclsFmt.addSubst(substVar, "(*this)");
   }
 };
 /// A specialized generator for operation interfaces.
 struct OpInterfaceGenerator : public InterfaceGenerator {

 /// A specialized generator for type interfaces.
 struct TypeInterfaceGenerator : public InterfaceGenerator {
   TypeInterfaceGenerator(const llvm::RecordKeeper &records, raw_ostream &os)
       : InterfaceGenerator(getAllInterfaceDefinitions(records, "Type"), os) {
     valueType = "::mlir::Type";
     interfaceBaseType = "TypeInterface";
     valueTemplate = "ConcreteType";
     substVar = "_type";
-    StringRef castCode = "(tablegen_opaque_val.cast<ConcreteType>())";
+    StringRef castCode = "(::llvm::cast<ConcreteType>(tablegen_opaque_val))";
     nonStaticMethodFmt.addSubst(substVar, castCode).withSelf(castCode);
     traitMethodFmt.addSubst(substVar,
                             "(*static_cast<const ConcreteType *>(this))");
     extraDeclsFmt.addSubst(substVar, "(*this)");
   }
 };
 } // namespace
 

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

if (attr.getAttrDefName() == "SPIRV_ScopeAttr" ||
       attr.getAttrDefName() == "SPIRV_MatrixLayoutAttr") {
     // These two enums are encoded as <id> to constant values in SPIR-V blob,
     // but we directly use the constant value as attribute in SPIR-V dialect. So
     // need to handle them separately from normal enum attributes.
     EnumAttr baseEnum(attr.getDef().getValueAsDef("enum"));
     os << tabs
        << formatv("  {0}.push_back(prepareConstantInt({1}.getLoc(), "
                   "Builder({1}).getI32IntegerAttr(static_cast<uint32_t>("
-                  "attr.cast<{2}::{3}Attr>().getValue()))));\n",
+                  "::llvm::cast<{2}::{3}Attr>(attr).getValue()))));\n",
                   operandList, opVar, baseEnum.getCppNamespace(),
                   baseEnum.getEnumClassName());
   } else if (attr.isSubClassOf("SPIRV_BitEnumAttr") ||
              attr.isSubClassOf("SPIRV_I32EnumAttr")) {
     EnumAttr baseEnum(attr.getDef().getValueAsDef("enum"));
     os << tabs
        << formatv("  {0}.push_back(static_cast<uint32_t>("
-                  "attr.cast<{1}::{2}Attr>().getValue()));\n",
+                  "::llvm::cast<{1}::{2}Attr>(attr).getValue()));\n",
                   operandList, baseEnum.getCppNamespace(),
                   baseEnum.getEnumClassName());
   } else if (attr.getAttrDefName() == "I32ArrayAttr") {
     // Serialize all the elements of the array
-    os << tabs << "  for (auto attrElem : attr.cast<ArrayAttr>()) {\n";
+    os << tabs << "  for (auto attrElem : llvm::cast<ArrayAttr>(attr)) {\n";
     os << tabs
        << formatv("    {0}.push_back(static_cast<uint32_t>("
-                  "attrElem.cast<IntegerAttr>().getValue().getZExtValue()));\n",
+                  "llvm::cast<IntegerAttr>(attrElem).getValue().getZExtValue())"
+                  ");\n",
                   operandList);
     os << tabs << "  }\n";
   } else if (attr.getAttrDefName() == "I32Attr") {
     os << tabs
-       << formatv("  {0}.push_back(static_cast<uint32_t>("
-                  "attr.cast<IntegerAttr>().getValue().getZExtValue()));\n",
-                  operandList);
+       << formatv(
+              "  {0}.push_back(static_cast<uint32_t>("
+              "llvm::cast<IntegerAttr>(attr).getValue().getZExtValue()));\n",
   } else if (attr.isEnumAttr() || attr.getAttrDefName() == "TypeAttr") {
     os << tabs
        << formatv("  {0}.push_back(static_cast<uint32_t>("
-                  "getTypeID(attr.cast<TypeAttr>().getValue())));\n",
+                  "getTypeID(llvm::cast<TypeAttr>(attr).getValue())));\n",
                   operandList);
   } else {
     PrintFatalError(
         loc,
         llvm::Twine(
             "unhandled attribute type in SPIR-V serialization generation : '") +
             attr.getAttrDefName() + llvm::Twine("'"));
   }