[mlir] Update cast/isa method calls to function calls

[tpopp]

Summary

This updates the rest (at implementation) of MLIR's use of cast/isa
method calls where function calls are possible and automatic refactoring
is not. These changes occured in .td files or in macros.

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/include/mlir/Dialect/OpenMP/OpenMPOpsInterfaces.td

InterfaceMethod<
       /*description=*/[{
         Get the FlagsAttr attribute on the current module if it exists
         and return the attribute, if it doesn't exit it returns a nullptr
       }],
       /*retTy=*/"mlir::omp::FlagsAttr",
       /*methodName=*/"getFlags",
       (ins), [{}], [{
         if (Attribute flags = $_op->getAttr("omp.flags"))
-          return flags.dyn_cast_or_null<mlir::omp::FlagsAttr>();
+          return ::llvm::dyn_cast_or_null<mlir::omp::FlagsAttr>(flags);
         return nullptr;
       }]>,
       InterfaceMethod<
       /*description=*/[{
         Apply an omp.FlagsAttr to a module with the specified values
         for the flags
       }],
       /*retTy=*/"void",
InterfaceMethod<
       /*description=*/[{
         Get the Target attribute on the current module if it exists
         and return the attribute, if it doesn't exist it returns a nullptr.
       }],
       /*retTy=*/"mlir::omp::TargetAttr",
       /*methodName=*/"getTarget",
       (ins), [{}], [{
         if (Attribute flags = $_op->getAttr("omp.target"))
-          return flags.dyn_cast_or_null<mlir::omp::TargetAttr>();
+          return ::llvm::dyn_cast_or_null<mlir::omp::TargetAttr>(flags);
         return nullptr;
       }]>,
     InterfaceMethod<
       /*description=*/[{
         Set the attribute target on the current module with the
         specified string arguments - name of cpu and corresponding features.
       }],
       /*retTy=*/"void",

mlir/include/mlir/IR/BuiltinAttributes.td

let extraClassDeclaration = [{
     /// sorted else it will be sorted in place before finding the duplicate entry.
     static std::optional<NamedAttribute>
     findDuplicate(SmallVectorImpl<NamedAttribute> &array, bool isSorted);
 
     /// Return the specified attribute if present and is an instance of
     /// `AttrClass`, null otherwise.
     template<typename AttrClass, typename NameClass>
     AttrClass getAs(NameClass &&name) const {
-      return get(std::forward<NameClass>(name))
-        .template dyn_cast_or_null<AttrClass>();
+      return llvm::dyn_cast_or_null<AttrClass>(
+               get(std::forward<NameClass>(name)));
     }
 
   private:
     /// Return empty dictionary.
     static DictionaryAttr getEmpty(MLIRContext *context);
 
     /// Return empty dictionary. This is a special variant of the above method
     /// that is used by the MLIRContext to cache the empty dictionary instance.

mlir/include/mlir/IR/EnumAttr.td

class EnumAttrInfo<
   bit genSpecializedAttr = 1;
   // The underlying Attribute class, which holds the enum value
   Attr baseAttrClass = baseClass;
   // The name of specialized Enum Attribute class
   string specializedAttrClassName = name # Attr;
 
   // Override Attr class fields for specialized class
   let predicate = !if(genSpecializedAttr,
-    CPred<"$_self.isa<" # cppNamespace # "::" # specializedAttrClassName # ">()">,
+    CPred<"::llvm::isa<" # cppNamespace # "::" # specializedAttrClassName # ">($_self)">,
     baseAttrClass.predicate);
   let storageType = !if(genSpecializedAttr,
     cppNamespace # "::" # specializedAttrClassName,
     baseAttrClass.storageType);
   let returnType = !if(genSpecializedAttr,
     cppNamespace # "::" # className,
     baseAttrClass.returnType);
   let constBuilderCall = !if(genSpecializedAttr,

mlir/include/mlir/IR/FunctionInterfaces.td

let extraSharedClassDeclaration = [{
     }
     Attribute getArgAttr(unsigned index, StringRef name) {
       auto argDict = getArgAttrDict(index);
       return argDict ? argDict.get(name) : nullptr;
     }
 
     template <typename AttrClass>
     AttrClass getArgAttrOfType(unsigned index, StringAttr name) {
-      return getArgAttr(index, name).template dyn_cast_or_null<AttrClass>();
+      return ::llvm::dyn_cast_or_null<AttrClass>(getArgAttr(index, name));
     }
     template <typename AttrClass>
     AttrClass getArgAttrOfType(unsigned index, StringRef name) {
-      return getArgAttr(index, name).template dyn_cast_or_null<AttrClass>();
+      return ::llvm::dyn_cast_or_null<AttrClass>(getArgAttr(index, name));
     }
 
     /// Set the attributes held by the argument at 'index'.
     void setArgAttrs(unsigned index, ArrayRef<NamedAttribute> attributes) {
       function_interface_impl::setArgAttrs($_op, index, attributes);
     }
 
     /// Set the attributes held by the argument at 'index'. `attributes` may be
let extraSharedClassDeclaration = [{
     }
     Attribute getResultAttr(unsigned index, StringRef name) {
       auto argDict = getResultAttrDict(index);
       return argDict ? argDict.get(name) : nullptr;
     }
 
     template <typename AttrClass>
     AttrClass getResultAttrOfType(unsigned index, StringAttr name) {
-      return getResultAttr(index, name).template dyn_cast_or_null<AttrClass>();
+      return ::llvm::dyn_cast_or_null<AttrClass>(getResultAttr(index, name));
     }
     template <typename AttrClass>
     AttrClass getResultAttrOfType(unsigned index, StringRef name) {
-      return getResultAttr(index, name).template dyn_cast_or_null<AttrClass>();
+      return ::llvm::dyn_cast_or_null<AttrClass>(getResultAttr(index, name));
     }
 
     /// Set the attributes held by the result at 'index'.
     void setResultAttrs(unsigned index, ArrayRef<NamedAttribute> attributes) {
       function_interface_impl::setResultAttrs($_op, index, attributes);
     }
 
     /// Set the attributes held by the result at 'index'. `attributes` may be

mlir/lib/Conversion/VectorToSPIRV/VectorToSPIRV.cpp

matchAndRewrite(vector::ReductionOp reduceOp, OpAdaptor adaptor,
 
     // Reduce them.
     Value result = values.front();
     for (Value next : llvm::ArrayRef(values).drop_front()) {
       switch (reduceOp.getKind()) {
 
 #define INT_AND_FLOAT_CASE(kind, iop, fop)                                     \
   case vector::CombiningKind::kind:                                            \
-    if (resultType.isa<IntegerType>()) {                                       \
+    if (llvm::isa<IntegerType>(resultType)) {                                  \
       result = rewriter.create<spirv::iop>(loc, resultType, result, next);     \
     } else {                                                                   \
-      assert(resultType.isa<FloatType>());                                     \
+      assert(llvm::isa<FloatType>(resultType));                                \
       result = rewriter.create<spirv::fop>(loc, resultType, result, next);     \
     }                                                                          \
     break
 
 #define INT_OR_FLOAT_CASE(kind, fop)                                           \
   case vector::CombiningKind::kind:                                            \
     result = rewriter.create<fop>(loc, resultType, result, next);              \
     break

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

for (Attribute arg : *argsAttr) {
         int64_t index = intAttr.getInt();
         // Args with elements of type index must be in range
         // [0..operands.size).
         if ((index < 0) || (index >= static_cast<int64_t>(getNumOperands())))
           return emitOpError("index argument is out of range");
 
         // Args with elements of type ArrayAttr must have a type.
       } else if (llvm::isa<ArrayAttr>(
-                     arg) /*&& arg.getType().isa<NoneType>()*/) {
+                     arg) /*&& llvm::isa<NoneType>(arg.getType())*/) {
         // FIXME: Array attributes never have types
         return emitOpError("array argument has no type");
       }
     }
   }
 
   if (std::optional<ArrayAttr> templateArgsAttr = getTemplateArgs()) {
     for (Attribute tArg : *templateArgsAttr) {

mlir/lib/Dialect/Tosa/IR/TosaCanonicalizations.cpp

OpFoldResult CastOp::fold(FoldAdaptor adaptor) {
 
   return {};
 }
 
 OpFoldResult ConstOp::fold(FoldAdaptor adaptor) { return getValueAttr(); }
 
 #define REDUCE_FOLDER(OP)                                                      \
   OpFoldResult OP::fold(FoldAdaptor adaptor) {                                 \
-    ShapedType inputTy = getInput().getType().cast<ShapedType>();              \
+    ShapedType inputTy = llvm::cast<ShapedType>(getInput().getType());         \
     if (!inputTy.hasRank())                                                    \
       return {};                                                               \
     if (inputTy.getDimSize(getAxis()) == 1)                                    \
       return getInput();                                                       \
     return {};                                                                 \
   }
 
 REDUCE_FOLDER(ReduceAllOp)

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

 
 #define REDUCE_SHAPE_INFER(OP)                                                 \
   LogicalResult OP::inferReturnTypeComponents(                                 \
       MLIRContext *context, ::std::optional<Location> location,                \
       ValueShapeRange operands, DictionaryAttr attributes,                     \
       OpaqueProperties properties, RegionRange regions,                        \
       SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {           \
     Type inputType =                                                           \
-        operands.getType()[0].cast<TensorType>().getElementType();             \
-    return ReduceInferReturnTypes(operands.getShape(0), inputType,             \
-                                  attributes.get("axis").cast<IntegerAttr>(),  \
-                                  inferredReturnShapes);                       \
+        llvm::cast<TensorType>(operands.getType()[0]).getElementType();        \
+    return ReduceInferReturnTypes(                                             \
+        operands.getShape(0), inputType,                                       \
+        llvm::cast<IntegerAttr>(attributes.get("axis")),                       \
+        inferredReturnShapes);                                                 \
   }                                                                            \
   COMPATIBLE_RETURN_TYPES(OP)
 
 REDUCE_SHAPE_INFER(tosa::ReduceAllOp)
 REDUCE_SHAPE_INFER(tosa::ReduceAnyOp)
 REDUCE_SHAPE_INFER(tosa::ReduceMaxOp)
 REDUCE_SHAPE_INFER(tosa::ReduceMinOp)
 REDUCE_SHAPE_INFER(tosa::ReduceProdOp)

mlir/lib/Dialect/Tosa/Utils/QuantUtils.cpp

case 32:
     computeMultiplierAndShiftTosaScale32(scale, multiplier, shift);
     return;
   default:
     assert(0 && "Unsupported Tosa quantized_scale regime specified!");
   }
 }
 
 #define GET_UQTYPE(input_type)                                                 \
-  ((input_type).getElementType().dyn_cast<quant::UniformQuantizedType>())
+  (llvm::dyn_cast<quant::UniformQuantizedType>((input_type).getElementType()))
 #define GET_QTYPE(input_type)                                                  \
-  ((input_type).getElementType().dyn_cast<quant::QuantizedType>())
+  (llvm::dyn_cast<quant::QuantizedType>((input_type).getElementType()))
 
 /// Method to build ConvOpQuantizationAttr, called from
 /// ConvOpQuantInfoBuilder/TransConvOpQuantInfoBuilder:
 /// input_zp: input zeropoint
 /// weight_zp: weight zeropoint.
 ConvOpQuantizationAttr
 mlir::tosa::buildConvOpQuantizationAttr(OpBuilder &builder, Value input,
                                         Value weight) {

mlir/test/python/python_test_ops.td

let extraClassDefinition = [{
     ::mlir::LogicalResult $cppClass::inferReturnTypeComponents(
       ::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location,
       ::mlir::ValueShapeRange operands, ::mlir::DictionaryAttr attributes,
       ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions,
       ::llvm::SmallVectorImpl<
         ::mlir::ShapedTypeComponents>& inferredShapedTypeComponents) {
       $cppClass::Adaptor adaptor(operands, attributes, properties, regions);
       auto operandType =
-          adaptor.getOperand().getType().cast<::mlir::ShapedType>();
+          ::llvm::cast<::mlir::ShapedType>(adaptor.getOperand().getType());
       if (operandType.hasRank()) {
         inferredShapedTypeComponents.emplace_back(operandType.getShape(),
             operandType.getElementType());
       } else {
         inferredShapedTypeComponents.emplace_back(operandType.getElementType());
       }
       return ::mlir::success();
     }