[mlir] Prevent implicit downcasting to interfaces

[rkayaith]

Summary

Currently conversions to interfaces may happen implicitly (e.g.
Attribute -> TypedAttr), failing a runtime assert if the interface
isn't actually implemented. This change marks the Interface(ValueT)
constructor as explicit so that a cast is required.

Where it was straightforward to I adjusted code to not require casts,
otherwise I just made them explicit.

Depends on D148491, D148492

[rkayaith]

mlir/lib/Dialect/Arith/IR/ArithCanonicalization.td

325–326

Not sure if this is the best way to do this, I couldn't figure out how to get DRR to do the cast.

mlir/include/mlir/Dialect/Arith/IR/Arith.h

bool applyCmpPredicate(arith::CmpIPredicate predicate, const APInt &lhs,
                        const APInt &rhs);
 
 /// Compute `lhs` `pred` `rhs`, where `pred` is one of the known floating point
 /// comparison predicates.
 bool applyCmpPredicate(arith::CmpFPredicate predicate, const APFloat &lhs,
                        const APFloat &rhs);
 
 /// Returns the identity value attribute associated with an AtomicRMWKind op.
-Attribute getIdentityValueAttr(AtomicRMWKind kind, Type resultType,
+TypedAttr getIdentityValueAttr(AtomicRMWKind kind, Type resultType,
                                OpBuilder &builder, Location loc);
 
 /// Returns the identity value associated with an AtomicRMWKind op.
 Value getIdentityValue(AtomicRMWKind op, Type resultType, OpBuilder &builder,
                        Location loc);
 
 /// Returns the value obtained by applying the reduction operation kind
 /// associated with a binary AtomicRMWKind op to `lhs` and `rhs`.
 Value getReductionOp(AtomicRMWKind op, OpBuilder &builder, Location loc,
                      Value lhs, Value rhs);
 
 arith::CmpIPredicate invertPredicate(arith::CmpIPredicate pred);
 } // namespace arith
 } // namespace mlir
 
 #endif // MLIR_DIALECT_ARITH_IR_ARITH_H_

mlir/include/mlir/Dialect/CommonFolders.h

if (operands[0].isa<SplatElementsAttr>() &&
     if (lhs.getType() != rhs.getType())
       return {};
 
     auto elementResult = calculate(lhs.getSplatValue<ElementValueT>(),
                                    rhs.getSplatValue<ElementValueT>());
     if (!elementResult)
       return {};
 
-    return DenseElementsAttr::get(resultType, *elementResult);
+    return DenseElementsAttr::get(cast<ShapedType>(resultType), *elementResult);
   }
 
   if (operands[0].isa<ElementsAttr>() && operands[1].isa<ElementsAttr>()) {
     // Operands are ElementsAttr-derived; perform an element-wise fold by
     // expanding the values.
     auto lhs = operands[0].cast<ElementsAttr>();
     auto rhs = operands[1].cast<ElementsAttr>();
     if (lhs.getType() != rhs.getType())
       return {};
 
     auto lhsIt = lhs.value_begin<ElementValueT>();
     auto rhsIt = rhs.value_begin<ElementValueT>();
     SmallVector<ElementValueT, 4> elementResults;
     elementResults.reserve(lhs.getNumElements());
     for (size_t i = 0, e = lhs.getNumElements(); i < e; ++i, ++lhsIt, ++rhsIt) {
       auto elementResult = calculate(*lhsIt, *rhsIt);
       if (!elementResult)
         return {};
       elementResults.push_back(*elementResult);
     }
 
-    return DenseElementsAttr::get(resultType, elementResults);
+    return DenseElementsAttr::get(cast<ShapedType>(resultType), elementResults);
   }
   return {};
 }
 
 /// Performs constant folding `calculate` with element-wise behavior on the two
 /// attributes in `operands` and returns the result if possible.
 /// Uses the operand element type for the element type of the returned
 /// attribute.
if (operands[0].isa<SplatElementsAttr>()) {
     // The operand is a splat so we can avoid expanding the values out and
     // just fold based on the splat value.
     auto op = operands[0].cast<SplatElementsAttr>();
     bool castStatus = true;
     auto elementResult =
         calculate(op.getSplatValue<ElementValueT>(), castStatus);
     if (!castStatus)
       return {};
-    return DenseElementsAttr::get(resType, elementResult);
+    return DenseElementsAttr::get(cast<ShapedType>(resType), elementResult);
   }
   if (operands[0].isa<ElementsAttr>()) {
     // Operand is ElementsAttr-derived; perform an element-wise fold by
     // expanding the value.
     auto op = operands[0].cast<ElementsAttr>();
     bool castStatus = true;
     auto opIt = op.value_begin<ElementValueT>();
     SmallVector<TargetElementValueT> elementResults;
     elementResults.reserve(op.getNumElements());
     for (size_t i = 0, e = op.getNumElements(); i < e; ++i, ++opIt) {
       auto elt = calculate(*opIt, castStatus);
       if (!castStatus)
         return {};
       elementResults.push_back(elt);
     }
 
-    return DenseElementsAttr::get(resType, elementResults);
+    return DenseElementsAttr::get(cast<ShapedType>(resType), elementResults);
   }
   return {};
 }
 
 } // namespace mlir
 
 #endif // MLIR_DIALECT_COMMONFOLDERS_H

mlir/include/mlir/Dialect/Linalg/Utils/Utils.h

 /// and offset is 0. Strictly speaking the offset 0 is not required in
 /// general, but non-zero offsets are not handled by SPIR-V backend at this
 /// point (and potentially cannot be handled).
 std::optional<SmallVector<ReassociationIndices>>
 getReassociationMapForFoldingUnitDims(ArrayRef<OpFoldResult> mixedSizes);
 
 /// Return the identity numeric value associated to the give op. Return
 /// std::nullopt if there is no known neutral element.
-std::optional<Attribute> getNeutralElement(Operation *op);
+std::optional<TypedAttr> getNeutralElement(Operation *op);
 
 //===----------------------------------------------------------------------===//
 // Fusion / Tiling utilities
 //===----------------------------------------------------------------------===//
 
 /// The type of loops to be generated during tiling.
 enum class LinalgTilingLoopType {
   Loops = 0,

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

let assemblyFormat = "$sym_name `:` $type attr-dict-with-keyword "
                        "`combiner` $reductionRegion "
                        "custom<AtomicReductionRegion>($atomicReductionRegion)";
 
   let extraClassDeclaration = [{
     PointerLikeType getAccumulatorType() {
       if (getAtomicReductionRegion().empty())
         return {};
 
-      return getAtomicReductionRegion().front().getArgument(0).getType();
+      return cast<PointerLikeType>(getAtomicReductionRegion().front().getArgument(0).getType());
     }
   }];
   let hasRegionVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // 2.19.5.4 reduction clause
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Dialect/Utils/StructuredOpsUtils.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_UTILS_STRUCTUREDOPSUTILS_H
 #define MLIR_DIALECT_UTILS_STRUCTUREDOPSUTILS_H
 
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/Location.h"
+#include "mlir/IR/TypeRange.h"
 #include "mlir/Support/LLVM.h"
 
 // Pull in all enum type definitions and utility function declarations.
 #include "mlir/Dialect/Utils/DialectUtilsEnums.h.inc"
 
 namespace mlir {
 
 class OpBuilder;
-class TypeRange;
-class ValueRange;
 class RewriterBase;
 
 /// Tests whether the given maps describe a row major matmul. The test is
 /// permutation-invariant. Note that this only checks the affine maps from an
 /// operation, so does not perform any checks on the math being performed within
 /// the reduction.
 bool isRowMajorMatmul(ArrayAttr indexingMaps);
 
protected:
   Operation *op;
 };
 
 // Clone the current operation with the operands. This is used to abstract away
 // the optional underlying region creation.
 // Note: this is a true builder that notifies the OpBuilder listener.
 Operation *clone(OpBuilder &b, Operation *op, TypeRange newResultTypes,
                  ValueRange newOperands);
+template <typename OpT>
+OpT clone(OpBuilder &b, OpT op, TypeRange newResultTypes,
+          ValueRange newOperands) {
+  return cast<OpT>(clone(b, op.getOperation(), newResultTypes, newOperands));
+}
 
 // Clone the current operation with the operands but leave the regions empty.
 // Note: this is a true builder that notifies the OpBuilder listener.
 Operation *cloneWithoutRegions(OpBuilder &b, Operation *op,
                                TypeRange newResultTypes,
                                ValueRange newOperands);
 
 // Get the list of attributes associated with the op, ignoring
 // those with the provided name.
 SmallVector<NamedAttribute>
 getPrunedAttributeList(Operation *op, ArrayRef<StringRef> elidedAttrs);
 
 } // namespace mlir
 
 #endif // MLIR_DIALECT_UTILS_STRUCTUREDOPSUTILS_H

mlir/include/mlir/IR/Builders.h

public:
   FloatAttr getFloatAttr(Type type, double value);
   FloatAttr getFloatAttr(Type type, const APFloat &value);
   StringAttr getStringAttr(const Twine &bytes);
   ArrayAttr getArrayAttr(ArrayRef<Attribute> value);
 
   // Returns a 0-valued attribute of the given `type`. This function only
   // supports boolean, integer, and 16-/32-/64-bit float types, and vector or
   // ranked tensor of them. Returns null attribute otherwise.
-  Attribute getZeroAttr(Type type);
+  TypedAttr getZeroAttr(Type type);
 
   // Convenience methods for fixed types.
   FloatAttr getF16FloatAttr(float value);
   FloatAttr getF32FloatAttr(float value);
   FloatAttr getF64FloatAttr(double value);
 
   IntegerAttr getI8IntegerAttr(int8_t value);
   IntegerAttr getI16IntegerAttr(int16_t value);

mlir/include/mlir/IR/BuiltinAttributes.h

 
 /// An attribute that represents a reference to a dense vector or tensor
 /// object.
 class DenseElementsAttr : public Attribute {
 public:
   using Attribute::Attribute;
 
   /// Allow implicit conversion to ElementsAttr.
-  operator ElementsAttr() const {
-    return *this ? cast<ElementsAttr>() : nullptr;
-  }
+  operator ElementsAttr() const { return cast_if_present<ElementsAttr>(*this); }
+  /// Allow implicit conversion to TypedAttr.
+  operator TypedAttr() const { return ElementsAttr(*this); }
 
   /// Type trait used to check if the given type T is a potentially valid C++
   /// floating point type that can be used to access the underlying element
   /// types of a DenseElementsAttr.
   template <typename T>
   struct is_valid_cpp_fp_type {
     /// The type is a valid floating point type if it is a builtin floating
     /// point type, or is a potentially user defined floating point type. The

 /// integers.
 class BoolAttr : public Attribute {
 public:
   using Attribute::Attribute;
   using ValueType = bool;
 
   static BoolAttr get(MLIRContext *context, bool value);
 
-  /// Enable conversion to IntegerAttr. This uses conversion vs. inheritance to
-  /// avoid bringing in all of IntegerAttrs methods.
+  /// Enable conversion to IntegerAttr and its interfaces. This uses conversion
+  /// vs. inheritance to avoid bringing in all of IntegerAttrs methods.
   operator IntegerAttr() const { return IntegerAttr(impl); }
+  operator TypedAttr() const { return IntegerAttr(impl); }
 
   /// Return the boolean value of this attribute.
   bool getValue() const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool classof(Attribute attr);
 };
 

mlir/include/mlir/IR/FunctionInterfaces.td

let extraSharedClassDeclaration = [{
     /// Change the type of this function in place. This is an extremely dangerous
     /// operation and it is up to the caller to ensure that this is legal for
     /// this function, and to restore invariants:
     ///  - the entry block args must be updated to match the function params.
     ///  - the argument/result attributes may need an update: if the new type
     ///    has less parameters we drop the extra attributes, if there are more
     ///    parameters they won't have any attributes.
     void setType(Type newType) {
-      function_interface_impl::setFunctionType(this->getOperation(), newType);
+      function_interface_impl::setFunctionType($_op, newType);
     }
 
     //===------------------------------------------------------------------===//
     // Argument and Result Handling
     //===------------------------------------------------------------------===//
 
     /// Returns the number of function arguments.
     unsigned getNumArguments() { return $_op.getArgumentTypes().size(); }
let extraSharedClassDeclaration = [{
     /// appear in the same order that they were listed here.
     void insertArguments(ArrayRef<unsigned> argIndices, TypeRange argTypes,
                         ArrayRef<DictionaryAttr> argAttrs,
                         ArrayRef<Location> argLocs) {
       unsigned originalNumArgs = $_op.getNumArguments();
       Type newType = $_op.getTypeWithArgsAndResults(
           argIndices, argTypes, /*resultIndices=*/{}, /*resultTypes=*/{});
       function_interface_impl::insertFunctionArguments(
-          this->getOperation(), argIndices, argTypes, argAttrs, argLocs,
+          $_op, argIndices, argTypes, argAttrs, argLocs,
           originalNumArgs, newType);
     }
 
     /// Insert a single result of type `resultType` at `resultIndex`.
     void insertResult(unsigned resultIndex, Type resultType,
                       DictionaryAttr resultAttrs) {
       insertResults({resultIndex}, {resultType}, {resultAttrs});
     }
 
     /// Inserts results with the listed types at the listed indices.
     /// `resultIndices` must be sorted. Results are inserted in the order they are
     /// listed, such that results with identical index will appear in the same
     /// order that they were listed here.
     void insertResults(ArrayRef<unsigned> resultIndices, TypeRange resultTypes,
                       ArrayRef<DictionaryAttr> resultAttrs) {
       unsigned originalNumResults = $_op.getNumResults();
       Type newType = $_op.getTypeWithArgsAndResults(
         /*argIndices=*/{}, /*argTypes=*/{}, resultIndices, resultTypes);
       function_interface_impl::insertFunctionResults(
-          this->getOperation(), resultIndices, resultTypes, resultAttrs,
+          $_op, resultIndices, resultTypes, resultAttrs,
           originalNumResults, newType);
     }
 
     /// Erase a single argument at `argIndex`.
     void eraseArgument(unsigned argIndex) {
       BitVector argsToErase($_op.getNumArguments());
       argsToErase.set(argIndex);
       eraseArguments(argsToErase);
     }
 
     /// Erases the arguments listed in `argIndices`.
     void eraseArguments(const BitVector &argIndices) {
       Type newType = $_op.getTypeWithoutArgs(argIndices);
       function_interface_impl::eraseFunctionArguments(
-        this->getOperation(), argIndices, newType);
+        $_op, argIndices, newType);
     }
 
     /// Erase a single result at `resultIndex`.
     void eraseResult(unsigned resultIndex) {
       BitVector resultsToErase($_op.getNumResults());
       resultsToErase.set(resultIndex);
       eraseResults(resultsToErase);
     }
 
     /// Erases the results listed in `resultIndices`.
     void eraseResults(const BitVector &resultIndices) {
       Type newType = $_op.getTypeWithoutResults(resultIndices);
       function_interface_impl::eraseFunctionResults(
-          this->getOperation(), resultIndices, newType);
+          $_op, resultIndices, newType);
     }
 
     /// Return the type of this function with the specified arguments and
     /// results inserted. This is used to update the function's signature in
     /// the `insertArguments` and `insertResults` methods. The arrays must be
     /// sorted by increasing index.
     Type getTypeWithArgsAndResults(
       ArrayRef<unsigned> argIndices, TypeRange argTypes,
let extraSharedClassDeclaration = [{
     }
 
     //===------------------------------------------------------------------===//
     // Argument Attributes
     //===------------------------------------------------------------------===//
 
     /// Return all of the attributes for the argument at 'index'.
     ArrayRef<NamedAttribute> getArgAttrs(unsigned index) {
-      return function_interface_impl::getArgAttrs(this->getOperation(), index);
+      return function_interface_impl::getArgAttrs($_op, index);
     }
 
     /// Return an ArrayAttr containing all argument attribute dictionaries of
     /// this function, or nullptr if no arguments have attributes.
     ArrayAttr getAllArgAttrs() { return $_op.getArgAttrsAttr(); }
 
     /// Return all argument attributes of this function.
     void getAllArgAttrs(SmallVectorImpl<DictionaryAttr> &result) {
let extraSharedClassDeclaration = [{
 
     /// Set the attributes held by the argument at 'index'. `attributes` may be
     /// null, in which case any existing argument attributes are removed.
     void setArgAttrs(unsigned index, DictionaryAttr attributes) {
       function_interface_impl::setArgAttrs($_op, index, attributes);
     }
     void setAllArgAttrs(ArrayRef<DictionaryAttr> attributes) {
       assert(attributes.size() == $_op.getNumArguments());
-      function_interface_impl::setAllArgAttrDicts(this->getOperation(), attributes);
+      function_interface_impl::setAllArgAttrDicts($_op, attributes);
     }
     void setAllArgAttrs(ArrayRef<Attribute> attributes) {
       assert(attributes.size() == $_op.getNumArguments());
-      function_interface_impl::setAllArgAttrDicts(this->getOperation(), attributes);
+      function_interface_impl::setAllArgAttrDicts($_op, attributes);
     }
     void setAllArgAttrs(ArrayAttr attributes) {
       assert(attributes.size() == $_op.getNumArguments());
       $_op.setArgAttrsAttr(attributes);
     }
 
     /// If the an attribute exists with the specified name, change it to the new
     /// value. Otherwise, add a new attribute with the specified name/value.
let extraSharedClassDeclaration = [{
     }
 
     //===------------------------------------------------------------------===//
     // Result Attributes
     //===------------------------------------------------------------------===//
 
     /// Return all of the attributes for the result at 'index'.
     ArrayRef<NamedAttribute> getResultAttrs(unsigned index) {
-      return function_interface_impl::getResultAttrs(this->getOperation(), index);
+      return function_interface_impl::getResultAttrs($_op, index);
     }
 
     /// Return an ArrayAttr containing all result attribute dictionaries of this
     /// function, or nullptr if no result have attributes.
     ArrayAttr getAllResultAttrs() { return $_op.getResAttrsAttr(); }
 
     /// Return all result attributes of this function.
     void getAllResultAttrs(SmallVectorImpl<DictionaryAttr> &result) {
let extraSharedClassDeclaration = [{
     /// Set the attributes held by the result at 'index'. `attributes` may be
     /// null, in which case any existing argument attributes are removed.
     void setResultAttrs(unsigned index, DictionaryAttr attributes) {
       function_interface_impl::setResultAttrs($_op, index, attributes);
     }
     void setAllResultAttrs(ArrayRef<DictionaryAttr> attributes) {
       assert(attributes.size() == $_op.getNumResults());
       function_interface_impl::setAllResultAttrDicts(
-        this->getOperation(), attributes);
+        $_op, attributes);
     }
     void setAllResultAttrs(ArrayRef<Attribute> attributes) {
       assert(attributes.size() == $_op.getNumResults());
       function_interface_impl::setAllResultAttrDicts(
-        this->getOperation(), attributes);
+        $_op, attributes);
     }
     void setAllResultAttrs(ArrayAttr attributes) {
       assert(attributes.size() == $_op.getNumResults());
       $_op.setResAttrsAttr(attributes);
     }
 
     /// If the an attribute exists with the specified name, change it to the new
     /// value. Otherwise, add a new attribute with the specified name/value.
Attribute removeResultAttr(unsigned index, StringAttr name) {
       return function_interface_impl::removeResultAttr($_op, index, name);
     }
 
     /// Returns the dictionary attribute corresponding to the argument at
     /// 'index'. If there are no argument attributes at 'index', a null
     /// attribute is returned.
     DictionaryAttr getArgAttrDict(unsigned index) {
       assert(index < $_op.getNumArguments() && "invalid argument number");
-      return function_interface_impl::getArgAttrDict(this->getOperation(), index);
+      return function_interface_impl::getArgAttrDict($_op, index);
     }
 
     /// Returns the dictionary attribute corresponding to the result at 'index'.
     /// If there are no result attributes at 'index', a null attribute is
     /// returned.
     DictionaryAttr getResultAttrDict(unsigned index) {
       assert(index < $_op.getNumResults() && "invalid result number");
-      return function_interface_impl::getResultAttrDict(this->getOperation(), index);
+      return function_interface_impl::getResultAttrDict($_op, index);
     }
   }];
 
   let verify = "return function_interface_impl::verifyTrait(cast<ConcreteOp>($_op));";
 }
 
 #endif // MLIR_IR_FUNCTIONINTERFACES_TD_

mlir/include/mlir/Support/InterfaceSupport.h

public:
   struct Trait : public BaseTrait<ConcreteT, Trait> {
     using ModelT = Model<ConcreteT>;
 
     /// Define an accessor for the ID of this interface.
     static TypeID getInterfaceID() { return TypeID::get<ConcreteType>(); }
   };
 
   /// Construct an interface from an instance of the value type.
-  Interface(ValueT t = ValueT())
+  explicit Interface(ValueT t = ValueT())
       : BaseType(t),
         conceptImpl(t ? ConcreteType::getInterfaceFor(t) : nullptr) {
     assert((!t || conceptImpl) &&
            "expected value to provide interface instance");
   }
   Interface(std::nullptr_t) : BaseType(ValueT()), conceptImpl(nullptr) {}
 
   /// Construct an interface instance from a type that implements this

mlir/lib/Conversion/ArithToLLVM/ArithToLLVM.cpp

LogicalResult MulIExtendedOpLowering<ArithMulOp, IsSigned>::matchAndRewrite(
 
   Location loc = op.getLoc();
 
   // Handle the scalar and 1D vector cases. Because LLVM does not have a
   // matching extended multiplication intrinsic, perform regular multiplication
   // on operands zero-extended to i(2*N) bits, and truncate the results back to
   // iN types.
   if (!resultType.isa<LLVM::LLVMArrayType>()) {
-    Type wideType;
     // Shift amount necessary to extract the high bits from widened result.
-    Attribute shiftValAttr;
+    TypedAttr shiftValAttr;
 
     if (auto intTy = resultType.dyn_cast<IntegerType>()) {
       unsigned resultBitwidth = intTy.getWidth();
-      wideType = rewriter.getIntegerType(resultBitwidth * 2);
-      shiftValAttr = rewriter.getIntegerAttr(wideType, resultBitwidth);
+      auto attrTy = rewriter.getIntegerType(resultBitwidth * 2);
+      shiftValAttr = rewriter.getIntegerAttr(attrTy, resultBitwidth);
     } else {
       auto vecTy = resultType.cast<VectorType>();
       unsigned resultBitwidth = vecTy.getElementTypeBitWidth();
-      wideType = VectorType::get(vecTy.getShape(),
-                                 rewriter.getIntegerType(resultBitwidth * 2));
+      auto attrTy = VectorType::get(
+          vecTy.getShape(), rewriter.getIntegerType(resultBitwidth * 2));
       shiftValAttr = SplatElementsAttr::get(
-          wideType, APInt(resultBitwidth * 2, resultBitwidth));
+          attrTy, APInt(resultBitwidth * 2, resultBitwidth));
     }
+    Type wideType = shiftValAttr.getType();
     assert(LLVM::isCompatibleType(wideType) &&
            "LLVM dialect should support all signless integer types");
 
     using LLVMExtOp = std::conditional_t<IsSigned, LLVM::SExtOp, LLVM::ZExtOp>;
     Value lhsExt = rewriter.create<LLVMExtOp>(loc, wideType, adaptor.getLhs());
     Value rhsExt = rewriter.create<LLVMExtOp>(loc, wideType, adaptor.getRhs());
     Value mulExt = rewriter.create<LLVM::MulOp>(loc, wideType, lhsExt, rhsExt);
 

mlir/lib/Conversion/TosaToArith/TosaToArith.cpp

 
 Type matchContainerType(Type element, Type container) {
   if (auto shapedTy = container.dyn_cast<ShapedType>())
     return shapedTy.clone(element);
 
   return element;
 }
 
-Attribute getConstantAttr(Type type, int64_t value, PatternRewriter &rewriter) {
+TypedAttr getConstantAttr(Type type, int64_t value, PatternRewriter &rewriter) {
   if (auto shapedTy = type.dyn_cast<ShapedType>()) {
     Type eTy = shapedTy.getElementType();
     APInt valueInt(eTy.getIntOrFloatBitWidth(), value);
     return DenseIntElementsAttr::get(shapedTy, valueInt);
   }
 
   return rewriter.getIntegerAttr(type, value);
 }

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

return rewriter.notifyMatchFailure(
         operation, "unable to create linalg.generic body for elementwise op");
 
   rewriter.replaceOp(operation, linalgOp->getResults());
   return success();
 }
 
 // Returns the constant initial value for a given reduction operation. The
 // attribute type varies depending on the element type required.
-static Attribute createInitialValueForReduceOp(Operation *op, Type elementTy,
+static TypedAttr createInitialValueForReduceOp(Operation *op, Type elementTy,
                                                PatternRewriter &rewriter) {
   if (isa<tosa::ReduceSumOp>(op) && elementTy.isa<FloatType>())
     return rewriter.getFloatAttr(elementTy, 0.0);
 
   if (isa<tosa::ReduceSumOp>(op) && elementTy.isa<IntegerType>())
     return rewriter.getIntegerAttr(elementTy, 0);
 
   if (isa<tosa::ReduceProdOp>(op) && elementTy.isa<FloatType>())

mlir/lib/Conversion/TosaToLinalg/TosaToLinalgNamed.cpp

 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 #include <numeric>
 
 using namespace mlir;
 using namespace mlir::tosa;
 
 static mlir::Value applyPad(Location loc, Value input, ArrayRef<int64_t> pad,
-                            Attribute padAttr, OpBuilder &rewriter) {
+                            TypedAttr padAttr, OpBuilder &rewriter) {
   // Input should be padded if necessary.
   if (llvm::all_of(pad, [](int64_t p) { return p == 0; }))
     return input;
 
   ShapedType inputTy = input.getType().cast<ShapedType>();
   Type inputETy = inputTy.getElementType();
   auto inputShape = inputTy.getShape();
 
matchAndRewrite(TosaConvOp op, typename TosaConvOp::Adaptor adaptor,
     SmallVector<Value> filteredDims = inferDynamicDimsForConv(
         loc, input, weight, resultTy, padAttr.asArrayRef(),
         strideTosaAttr.asArrayRef(), dilationTosaAttr.asArrayRef(),
         inputSizeDims, kernelSizeDims, rewriter);
 
     auto weightShape = weightTy.getShape();
 
     // Apply padding as necessary.
-    Attribute zeroAttr = rewriter.getZeroAttr(inputETy);
+    TypedAttr zeroAttr = rewriter.getZeroAttr(inputETy);
     if (isQuantized) {
       auto quantizationInfo = *op.getQuantizationInfo();
       int64_t iZp = quantizationInfo.getInputZp();
 
       int64_t intMin =
           APInt::getSignedMinValue(inputETy.getIntOrFloatBitWidth())
               .getSExtValue();
       int64_t intMax =
matchAndRewrite(TosaConvOp op, typename TosaConvOp::Adaptor adaptor,
     auto weightPermAttr = rewriter.getI64TensorAttr(weightPerm);
     Value weightPermValue =
         rewriter.create<arith::ConstantOp>(loc, weightPermAttr);
     Type newWeightTy =
         RankedTensorType::get(newWeightShape, weightTy.getElementType());
     weight = rewriter.create<tosa::TransposeOp>(loc, newWeightTy, weight,
                                                 weightPermValue);
 
-    Attribute resultZeroAttr = rewriter.getZeroAttr(resultETy);
+    auto resultZeroAttr = rewriter.getZeroAttr(resultETy);
     Value emptyTensor = rewriter.create<tensor::EmptyOp>(
         loc, resultTy.getShape(), resultETy, filteredDims);
     Value zero = rewriter.create<arith::ConstantOp>(loc, resultZeroAttr);
     Value zeroTensor = rewriter
                            .create<linalg::FillOp>(loc, ValueRange{zero},
                                                    ValueRange{emptyTensor})
                            .result();
 
if (isQuantized) {
       iZp = rewriter.getI32IntegerAttr(quantizationInfo.getInputZp());
       kZp = rewriter.getI32IntegerAttr(quantizationInfo.getWeightZp());
     }
 
     auto weightShape = weightTy.getShape();
     auto resultShape = resultTy.getShape();
 
     // Apply padding as necessary.
-    Attribute zeroAttr = rewriter.getZeroAttr(inputETy);
+    TypedAttr zeroAttr = rewriter.getZeroAttr(inputETy);
     if (isQuantized) {
       auto quantizationInfo =
           op->getAttr("quantization_info").cast<tosa::ConvOpQuantizationAttr>();
       int64_t iZp = quantizationInfo.getInputZp();
 
       int64_t intMin =
           APInt::getSignedMinValue(inputETy.getIntOrFloatBitWidth())
               .getSExtValue();
matchAndRewrite(tosa::DepthwiseConv2DOp op, OpAdaptor adaptor,
     // Broadcast the initial value to the output tensor before convolving.
     SmallVector<AffineMap, 4> indexingMaps;
     indexingMaps.push_back(AffineMap::get(
         /*dimCount=*/resultRank, /*symbolCount=*/0,
         {rewriter.getAffineDimExpr(3)}, rewriter.getContext()));
     indexingMaps.push_back(rewriter.getMultiDimIdentityMap(resultRank));
     indexingMaps.push_back(rewriter.getMultiDimIdentityMap(resultRank));
 
-    Attribute resultZeroAttr = rewriter.getZeroAttr(resultETy);
+    auto resultZeroAttr = rewriter.getZeroAttr(resultETy);
     Value emptyTensor = rewriter.create<tensor::EmptyOp>(
         loc, linalgConvTy.getShape(), resultETy, filteredDims);
     Value zero = rewriter.create<arith::ConstantOp>(loc, resultZeroAttr);
     Value zeroTensor = rewriter
                            .create<linalg::FillOp>(loc, ValueRange{zero},
                                                    ValueRange{emptyTensor})
                            .result();
 
matchAndRewrite(tosa::FullyConnectedOp op, OpAdaptor adaptor,
 
     indexingMaps.push_back(rewriter.getMultiDimIdentityMap(outputTy.getRank()));
     indexingMaps.push_back(rewriter.getMultiDimIdentityMap(outputTy.getRank()));
 
     auto emptyTensor = rewriter.create<tensor::EmptyOp>(
         loc, outputTy.getShape(), outputTy.getElementType(), filteredDims);
 
     // When quantized, the input elemeny type is not the same as the output
-    Attribute resultZeroAttr = rewriter.getZeroAttr(outputETy);
+    auto resultZeroAttr = rewriter.getZeroAttr(outputETy);
     Value zero = rewriter.create<arith::ConstantOp>(loc, resultZeroAttr);
     Value zeroTensor = rewriter
                            .create<linalg::FillOp>(loc, ValueRange{zero},
                                                    ValueRange{emptyTensor})
                            .result();
 
     SmallVector<int64_t> permutation{1, 0};
     auto permutationAttr = rewriter.getI64TensorAttr(permutation);
LogicalResult matchAndRewrite(tosa::MaxPool2dOp op,
 
     auto dynamicDimsOr =
         checkHasDynamicBatchDims(rewriter, op, {input, op.getOutput()});
     if (!dynamicDimsOr.has_value())
       return failure();
     SmallVector<Value> dynamicDims = *dynamicDimsOr;
 
     // Determine what the initial value needs to be for the max pool op.
-    Attribute initialAttr;
+    TypedAttr initialAttr;
     if (resultETy.isF32())
       initialAttr = rewriter.getFloatAttr(
           resultETy,
           APFloat::getLargest(resultETy.cast<FloatType>().getFloatSemantics(),
                               true));
 
     if (resultETy.isa<IntegerType>())
       initialAttr = rewriter.getIntegerAttr(
if (!dynamicDimsOr.has_value())
       return failure();
     SmallVector<Value> dynamicDims = *dynamicDimsOr;
 
     // Apply padding as necessary.
     llvm::SmallVector<int64_t> pad;
     pad.resize(2, 0);
     llvm::append_range(pad, op.getPad());
     pad.resize(pad.size() + 2, 0);
-    Attribute padAttr = rewriter.getZeroAttr(inElementTy);
+    TypedAttr padAttr = rewriter.getZeroAttr(inElementTy);
     Value paddedInput = applyPad(loc, input, pad, padAttr, rewriter);
 
-    Attribute initialAttr = rewriter.getZeroAttr(accETy);
+    auto initialAttr = rewriter.getZeroAttr(accETy);
     Value initialValue = rewriter.create<arith::ConstantOp>(loc, initialAttr);
 
     ArrayRef<int64_t> kernel = op.getKernel();
     ArrayRef<int64_t> stride = op.getStride();
 
     Attribute strideAttr = rewriter.getI64VectorAttr(stride);
     Attribute dilationAttr = rewriter.getI64VectorAttr({1, 1});
 

mlir/lib/Conversion/TosaToTensor/TosaToTensor.cpp

LogicalResult matchAndRewrite(tosa::PadOp padOp,
     // Setup the default constantAttr.
 
     Value padConstant;
 
     if (padOp.getPadConst()) {
       padConstant = rewriter.createOrFold<tensor::ExtractOp>(
           loc, padOp.getPadConst(), ValueRange({}));
     } else {
-      Attribute constantAttr;
+      TypedAttr constantAttr;
       if (elementTy.isa<FloatType>()) {
         constantAttr = rewriter.getFloatAttr(elementTy, 0.0);
       } else if (elementTy.isa<IntegerType>() && !padOp.getQuantizationInfo()) {
         constantAttr = rewriter.getIntegerAttr(elementTy, 0);
       } else if (elementTy.isa<IntegerType>() && padOp.getQuantizationInfo()) {
         int64_t value = padOp.getQuantizationInfo()->getInputZp();
         constantAttr = rewriter.getIntegerAttr(elementTy, value);
       }

mlir/lib/Dialect/Affine/Utils/Utils.cpp

static void createNewDynamicSizes(MemRefType oldMemRefType,
   unsigned dynIdx = 0;
   for (unsigned d = 0; d < oldMemRefType.getRank(); ++d) {
     if (oldMemRefShape[d] < 0) {
       // Use dynamicSizes of allocOp for dynamic dimension.
       inAffineApply.emplace_back(allocOp->getDynamicSizes()[dynIdx]);
       dynIdx++;
     } else {
       // Create ConstantOp for static dimension.
-      Attribute constantAttr =
-          b.getIntegerAttr(b.getIndexType(), oldMemRefShape[d]);
+      auto constantAttr = b.getIntegerAttr(b.getIndexType(), oldMemRefShape[d]);
       inAffineApply.emplace_back(
           b.create<arith::ConstantOp>(allocOp->getLoc(), constantAttr));
     }
   }
 
   // Create new map to calculate each dimension size of new memref for each
   // original map output. Only for dynamic dimesion of `newMemRefType`.
   unsigned newDimIdx = 0;

mlir/lib/Dialect/Arith/IR/ArithCanonicalization.td

 def GetZeroAttr : NativeCodeCall<"$_builder.getZeroAttr($0.getType())">;
 
 // Add two integer attributes and create a new one with the result.
 def AddIntAttrs : NativeCodeCall<"addIntegerAttrs($_builder, $0, $1, $2)">;
 
 // Subtract two integer attributes and createa a new one with the result.
 def SubIntAttrs : NativeCodeCall<"subIntegerAttrs($_builder, $0, $1, $2)">;
 
+class cast<string type> : NativeCodeCall<"::mlir::cast<" # type # ">($0)">;
+
 //===----------------------------------------------------------------------===//
 // AddIOp
 //===----------------------------------------------------------------------===//
 
 // addi is commutative and will be canonicalized to have its constants appear
 // as the second operand.
 
 // addi(addi(x, c0), c1) -> addi(x, c0 + c1)
def TruncationMatchesShiftAmount :
     Constraint<And<[
       CPred<"succeeded(getIntOrSplatIntValue($2))">,
       CPred<"(getScalarOrElementWidth($0) - getScalarOrElementWidth($1)) == "
               "*getIntOrSplatIntValue($2)">]>>;
 
 // trunci(shrsi(x, c)) -> trunci(shrui(x, c))
 def TruncIShrSIToTrunciShrUI :
     Pat<(Arith_TruncIOp:$tr
-          (Arith_ShRSIOp $x, (ConstantLikeMatcher AnyAttr:$c0))),
-        (Arith_TruncIOp (Arith_ShRUIOp $x, (Arith_ConstantOp $c0))),
+          (Arith_ShRSIOp $x, (ConstantLikeMatcher TypedAttrInterface:$c0))),
+        (Arith_TruncIOp (Arith_ShRUIOp $x, (Arith_ConstantOp (cast<"TypedAttr"> $c0)))),
         [(TruncationMatchesShiftAmount $x, $tr, $c0)]>;
 
 // trunci(shrui(mul(sext(x), sext(y)), c)) -> mulsi_extended(x, y)
 def TruncIShrUIMulIToMulSIExtended :
     Pat<(Arith_TruncIOp:$tr (Arith_ShRUIOp
                               (Arith_MulIOp:$mul
                                 (Arith_ExtSIOp $x), (Arith_ExtSIOp $y)),
                               (ConstantLikeMatcher AnyAttr:$c0))),

mlir/lib/Dialect/Arith/IR/ArithOps.cpp

OpFoldResult arith::ShRSIOp::fold(FoldAdaptor adaptor) {
   return bounded ? result : Attribute();
 }
 
 //===----------------------------------------------------------------------===//
 // Atomic Enum
 //===----------------------------------------------------------------------===//
 
 /// Returns the identity value attribute associated with an AtomicRMWKind op.
-Attribute mlir::arith::getIdentityValueAttr(AtomicRMWKind kind, Type resultType,
+TypedAttr mlir::arith::getIdentityValueAttr(AtomicRMWKind kind, Type resultType,
                                             OpBuilder &builder, Location loc) {
   switch (kind) {
   case AtomicRMWKind::maxf:
     return builder.getFloatAttr(
         resultType,
         APFloat::getInf(resultType.cast<FloatType>().getFloatSemantics(),
                         /*Negative=*/true));
   case AtomicRMWKind::addf:
default:
     break;
   }
   return nullptr;
 }
 
 /// Returns the identity value associated with an AtomicRMWKind op.
 Value mlir::arith::getIdentityValue(AtomicRMWKind op, Type resultType,
                                     OpBuilder &builder, Location loc) {
-  Attribute attr = getIdentityValueAttr(op, resultType, builder, loc);
+  auto attr = getIdentityValueAttr(op, resultType, builder, loc);
   return builder.create<arith::ConstantOp>(loc, attr);
 }
 
 /// Return the value obtained by applying the reduction operation kind
 /// associated with a binary AtomicRMWKind op to `lhs` and `rhs`.
 Value mlir::arith::getReductionOp(AtomicRMWKind op, OpBuilder &builder,
                                   Location loc, Value lhs, Value rhs) {
   switch (op) {

mlir/lib/Dialect/Arith/Transforms/EmulateWideInt.cpp

static Type reduceInnermostDim(VectorType type) {
   newShape.back() = 1;
   return VectorType::get(newShape, type.getElementType());
 }
 
 /// Returns a constant of integer of vector type filled with (repeated) `value`.
 static Value createScalarOrSplatConstant(ConversionPatternRewriter &rewriter,
                                          Location loc, Type type,
                                          const APInt &value) {
-  Attribute attr;
+  TypedAttr attr;
   if (auto intTy = type.dyn_cast<IntegerType>()) {
     attr = rewriter.getIntegerAttr(type, value);
   } else {
     auto vecTy = type.cast<VectorType>();
     attr = SplatElementsAttr::get(vecTy, value);
   }
 
   return rewriter.create<arith::ConstantOp>(loc, attr);
Value hiEqZero = rewriter.create<arith::CmpIOp>(
         loc, arith::CmpIPredicate::eq, hiInt, zeroCst);
 
     Type resultTy = op.getType();
     Type resultElemTy = getElementTypeOrSelf(resultTy);
     Value lowFp = rewriter.create<arith::UIToFPOp>(loc, resultTy, lowInt);
     Value hiFp = rewriter.create<arith::UIToFPOp>(loc, resultTy, hiInt);
 
     int64_t pow2Int = int64_t(1) << newBitWidth;
-    Attribute pow2Attr =
+    TypedAttr pow2Attr =
         rewriter.getFloatAttr(resultElemTy, static_cast<double>(pow2Int));
     if (auto vecTy = dyn_cast<VectorType>(resultTy))
       pow2Attr = SplatElementsAttr::get(vecTy, pow2Attr);
 
     Value pow2Val = rewriter.create<arith::ConstantOp>(loc, resultTy, pow2Attr);
 
     Value hiVal = rewriter.create<arith::MulFOp>(loc, hiFp, pow2Val);
     Value result = rewriter.create<arith::AddFOp>(loc, lowFp, hiVal);

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

 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 /// The constant op requires that the attribute's type matches the return type.
 LogicalResult emitc::ConstantOp::verify() {
   if (getValueAttr().isa<emitc::OpaqueAttr>())
     return success();
 
-  TypedAttr value = getValueAttr();
+  auto value = cast<TypedAttr>(getValueAttr());
   Type type = getType();
   if (!value.getType().isa<NoneType>() && type != value.getType())
     return emitOpError() << "requires attribute's type (" << value.getType()
                          << ") to match op's return type (" << type << ")";
   return success();
 }
 
 OpFoldResult emitc::ConstantOp::fold(FoldAdaptor adaptor) {

 // VariableOp
 //===----------------------------------------------------------------------===//
 
 /// The variable op requires that the attribute's type matches the return type.
 LogicalResult emitc::VariableOp::verify() {
   if (getValueAttr().isa<emitc::OpaqueAttr>())
     return success();
 
-  TypedAttr value = getValueAttr();
+  auto value = cast<TypedAttr>(getValueAttr());
   Type type = getType();
   if (!value.getType().isa<NoneType>() && type != value.getType())
     return emitOpError() << "requires attribute's type (" << value.getType()
                          << ") to match op's return type (" << type << ")";
   return success();
 }
 
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/GPU/TransformOps/GPUTransformOps.cpp

static DiagnosedSilenceableFailure rewriteOneForallCommonImpl(
   }
   LLVM_DEBUG(
       llvm::interleaveComma(
           tmpMappingSizes,
           DBGS() << "----tmpMappingSizes extracted from scf.forall op: ");
       llvm::dbgs() << "\n");
 
   // Step 2. sort the values by the corresponding DeviceMappingAttrInterface.
-  auto comparator = [&](DeviceMappingAttrInterface a,
-                        DeviceMappingAttrInterface b) -> bool {
-    return a.getMappingId() < b.getMappingId();
+  auto comparator = [&](Attribute a, Attribute b) -> bool {
+    return cast<DeviceMappingAttrInterface>(a).getMappingId() <
+           cast<DeviceMappingAttrInterface>(b).getMappingId();
   };
   SmallVector<int64_t> forallMappingSizes =
       getValuesSortedByKey(forallMappingAttrs, tmpMappingSizes, comparator);
   LLVM_DEBUG(llvm::interleaveComma(forallMappingSizes,
                                    DBGS() << "----forallMappingSizes: ");
              llvm::dbgs() << "\n"; llvm::interleaveComma(
                  forallMappingAttrs, DBGS() << "----mappingAttrs: ");
              llvm::dbgs() << "\n");

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

void yieldOutputs(ValueRange values) {
     Location loc = builder.getUnknownLoc();
     builder.create<YieldOp>(loc, values);
   }
 
   Value constant(const std::string &value) {
     OpBuilder builder = getBuilder();
     Location loc = builder.getUnknownLoc();
     Attribute valueAttr = parseAttribute(value, builder.getContext());
-    Type type = NoneType::get(builder.getContext());
-    if (auto typedAttr = valueAttr.dyn_cast<TypedAttr>())
-      type = typedAttr.getType();
-    return builder.create<arith::ConstantOp>(loc, type, valueAttr);
+    return builder.create<arith::ConstantOp>(loc, ::cast<TypedAttr>(valueAttr));
   }
 
   Value index(int64_t dim) {
     OpBuilder builder = getBuilder();
     return builder.create<IndexOp>(builder.getUnknownLoc(), dim);
   }
 
   Type getIntegerType(unsigned width) {

mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp

for (OpOperand *operand : producer.getDpsInitOperands()) {
     SmallVector<int64_t, 4> staticSizesVector(rank, ShapedType::kDynamic);
     SmallVector<int64_t, 4> staticStridesVector(
         rank, ShapedType::kDynamic);
     resultTypes.push_back(tensor::ExtractSliceOp::inferResultType(
         tensorType, staticOffsetsVector, staticSizesVector,
         staticStridesVector));
   }
 
-  Operation *clonedOp = clone(b, producer, resultTypes, clonedShapes);
+  LinalgOp clonedOp = clone(b, producer, resultTypes, clonedShapes);
 
   // Shift all IndexOp results by the tile offset.
   SmallVector<OpFoldResult> allIvs = llvm::to_vector(
       llvm::map_range(loopRanges, [&](Range range) { return range.offset; }));
   offsetIndices(b, clonedOp, allIvs);
 
   return clonedOp;
 }

mlir/lib/Dialect/Linalg/Transforms/FusionOnTensors.cpp

 /// Returns the tiled slice dimensions given the tiled consumer loop dimensions.
 /// The slice defines a hyper rectangular iteration space and fusing the
 /// producer is always possible. However, depending on the consumer indexing
 /// map, not all slice elements may be consumed and the tiles may overlap. In
 /// these cases, fusion introduces redundant computation.
 static SmallVector<int64_t> getTiledSliceDims(OpOperand *consumerOperand,
                                               ArrayRef<int64_t> tiledLoopDims) {
   // Get the consumer operand indexing map.
-  LinalgOp consumerOp = consumerOperand->getOwner();
+  auto consumerOp = cast<LinalgOp>(consumerOperand->getOwner());
   AffineMap indexingMap = consumerOp.getMatchingIndexingMap(consumerOperand);
 
   // Search the slice dimensions tiled by a tile loop dimension.
   DenseSet<int64_t> tiledSliceDimIndices;
   for (const auto &en : enumerate(indexingMap.getResults())) {
     for (auto tiledLoopDim : tiledLoopDims) {
       if (en.value().isFunctionOfDim(tiledLoopDim))
         tiledSliceDimIndices.insert(en.index());

 /// scf.for %i
 ///   scf.for %j
 ///     %slice = tensor.extract_slice %res[%i, %j]
 /// ```
 /// getTiledProducerLoops(%res, [0, 1]) returns the loop indices [0, 1].
 static SmallVector<int64_t>
 getTiledProducerLoops(OpResult producerResult,
                       ArrayRef<int64_t> tiledSliceDimIndices) {
-  LinalgOp producerOp = producerResult.getOwner();
+  auto producerOp = cast<LinalgOp>(producerResult.getOwner());
 
   // Get the indexing map of the `producerOp` output operand that matches
   // ´producerResult´.
   AffineMap producerIndexingMap = producerOp.getMatchingIndexingMap(
       producerOp.getDpsInitOperand(producerResult.getResultNumber()));
 
   // Keep only the tiled result slice dimensions of `producerIndexingMap`.
   AffineMap tiledProducerIndexingSubMap =
static LinalgOp getTiledProducer(OpBuilder &b, OpResult producerResult,
                                  ArrayRef<int64_t> tiledProducerLoopIndices,
                                  OpOperand *iterArg) {
   // Clone the producer after `sliceOp` since the slice may be reused to pass in
   // the producer result.
   OpBuilder::InsertionGuard guard(b);
   b.setInsertionPointAfter(sliceOp);
 
   // Get the producer.
-  LinalgOp producerOp = producerResult.getOwner();
+  auto producerOp = cast<LinalgOp>(producerResult.getOwner());
   Location loc = producerOp.getLoc();
 
   // Obtain the `producerOp` loop bounds and the `sliceOp` ranges.
   SmallVector<OpFoldResult> producerLoopBounds;
   llvm::transform(producerOp.createLoopRanges(b, loc),
                   std::back_inserter(producerLoopBounds),
                   [&](Range range) { return range.size; });
   SmallVector<Range> sliceOpRanges = sliceOp.getOrCreateRanges(b, loc);
FailureOr<LinalgOp> TileLoopNest::fuseProducer(OpBuilder &b,
 
   // Check `consumerOpOperand` is defined by an ExtractSliceOp.
   auto sliceOp =
       consumerOpOperand->get().getDefiningOp<tensor::ExtractSliceOp>();
   if (!sliceOp)
     return failure();
 
   // Check `sliceOp` and `consumerOp` are in the same block.
-  LinalgOp consumerOp = consumerOpOperand->getOwner();
+  auto consumerOp = cast<LinalgOp>(consumerOpOperand->getOwner());
   if (sliceOp->getBlock() != rootOp->getBlock() ||
       consumerOp->getBlock() != rootOp->getBlock())
     return failure();
 
   // Check `consumerOpOperand` is not shape-only to avoid fusion if the data is
   // not used by the `consumerOp` computation.
   BlockArgument bbArg = consumerOp.getMatchingBlockArgument(consumerOpOperand);
   if (bbArg.getUses().empty())

mlir/lib/Dialect/Linalg/Transforms/Loops.cpp

llvm::TypeSwitch<Operation *>(loopOp)
           allIvs.push_back(affineForOp.getInductionVar());
         })
         .Default([&](Operation *op) { assert(false && "unexpected op"); });
   }
   assert(linalgOp.getNumLoops() == allIvs.size() &&
          "expected the number of loops and induction variables to match");
   // Replace the index operations in the body of the innermost loop op.
   if (!loopOps.empty()) {
-    LoopLikeOpInterface loopOp = loopOps.back();
+    auto loopOp = cast<LoopLikeOpInterface>(loopOps.back());
     for (IndexOp indexOp :
          llvm::make_early_inc_range(loopOp.getLoopBody().getOps<IndexOp>()))
       rewriter.replaceOp(indexOp, allIvs[indexOp.getDim()]);
   }
 }
 
 template <typename LoopTy>
 static FailureOr<LinalgLoops> linalgOpToLoopsImpl(RewriterBase &rewriter,

mlir/lib/Dialect/Linalg/Transforms/SplitReduction.cpp

return b.notifyMatchFailure(op, "Insert dimension position too large "
                                     "compared to intermediate tensor size");
 
   SmallVector<Operation *, 4> combinerOps;
   if (!matchReduction(op.getRegionOutputArgs(), 0, combinerOps) ||
       combinerOps.size() != 1)
     return b.notifyMatchFailure(op, "Cannot match the reduction pattern");
 
   Operation *reductionOp = combinerOps[0];
-  std::optional<Attribute> identity = getNeutralElement(reductionOp);
+  std::optional<TypedAttr> identity = getNeutralElement(reductionOp);
   if (!identity.has_value())
     return b.notifyMatchFailure(op, "Unknown identity value for the reduction");
 
   Location loc = op->getLoc();
   SmallVector<Value> newInputs;
   SmallVector<AffineMap> newMaps;
   // Calculate the new shapes and indexing maps of the input operands.
   for (OpOperand *operand : op.getDpsInputOperands()) {
if (reductionDimSize == ShapedType::kDynamic ||
       insertSplitDimension >= loopRanges.size())
     return b.notifyMatchFailure(
         op, "first reduction dimension not divisible by split factor");
 
   SmallVector<Operation *> combinerOps;
   if (!matchReduction(op.getRegionOutputArgs(), 0, combinerOps))
     return b.notifyMatchFailure(op, "cannot match a reduction pattern");
 
-  SmallVector<Attribute> neutralElements;
+  SmallVector<TypedAttr> neutralElements;
   for (Operation *reductionOp : combinerOps) {
-    std::optional<Attribute> neutralElement = getNeutralElement(reductionOp);
+    std::optional<TypedAttr> neutralElement = getNeutralElement(reductionOp);
     if (!neutralElement.has_value())
       return b.notifyMatchFailure(op, "cannot find neutral element.");
     neutralElements.push_back(*neutralElement);
   }
   if (!llvm::all_of(neutralElements, [](Attribute attr) { return attr; }))
     return b.notifyMatchFailure(op, "unknown reduction neutral");
 
   // TODO: relax this when multi-reduction support is available.

mlir/lib/Dialect/Linalg/Transforms/TilingInterfaceImpl.cpp

assert(sizes.size() >= static_cast<size_t>(insertSplitDimension) &&
            "reduction dimension must be tiled");
 
     SmallVector<Operation *, 4> combinerOps;
     if (!matchReduction(linalgOp.getRegionOutputArgs(), 0, combinerOps) ||
         combinerOps.size() != 1)
       return op->emitOpError("Failed to anaysis the reduction operation.");
 
     Operation *reductionOp = combinerOps[0];
-    std::optional<Attribute> identity = getNeutralElement(reductionOp);
+    std::optional<TypedAttr> identity = getNeutralElement(reductionOp);
     if (!identity.has_value())
       return op->emitOpError(
           "Failed to get an identity value for the reduction operation.");
 
     // Calculate the new shape, we insert the new dimension based on the index
     // of the reduction dimension.
     SmallVector<int64_t> newOutputShape;
     ArrayRef<int64_t> oldShape =
for (auto [idx, expr] : llvm::enumerate(oldOutputMap.getResults())) {
       }
       outputExpr.push_back(expr);
     }
     if (insertSplitDimension == oldOutputMap.getNumResults())
       outputExpr.push_back(b.getAffineDimExpr(reductionDims[0]));
 
     // Step 1: Extract a slice of the input operands.
     SmallVector<Value> valuesToTile = linalgOp.getDpsInputOperands();
-    SmallVector<Value, 4> tiledOperands =
-        makeTiledShapes(b, loc, op, valuesToTile, offsets, sizes, {}, true);
+    SmallVector<Value, 4> tiledOperands = makeTiledShapes(
+        b, loc, linalgOp, valuesToTile, offsets, sizes, {}, true);
 
     // Step 2: Extract the accumulator operands
     SmallVector<OpFoldResult> strides(offsets.size(), b.getIndexAttr(1));
     SmallVector<OpFoldResult> outOffsets(offsets.size(), b.getIndexAttr(0));
     // TODO: use SubsetExtractOpInterface once it is available.
     Value out = b.create<tensor::ExtractSliceOp>(loc, init[0], outOffsets,
                                                  sizes, strides);
 

mlir/lib/Dialect/Linalg/Transforms/Transforms.cpp

static FailureOr<Value> padOperandToSmallestStaticBoundingBox(
   if (!nofold && hasStaticShape)
     return opOperand->get();
 
   // Fail if `paddingValues` specifies no padding value.
   if (opOperand->getOperandNumber() >= paddingValues.size()) {
     return rewriter.notifyMatchFailure(opToPad, "--no padding value specified");
   }
   Attribute paddingAttr = paddingValues[opOperand->getOperandNumber()];
-  Type paddingType = rewriter.getType<NoneType>();
-  if (auto typedAttr = paddingAttr.dyn_cast<TypedAttr>())
-    paddingType = typedAttr.getType();
   Value paddingValue = rewriter.create<arith::ConstantOp>(
-      opToPad.getLoc(), paddingType, paddingAttr);
+      opToPad.getLoc(), cast<TypedAttr>(paddingAttr));
 
   // Follow the use-def chain if `currOpOperand` is defined by a LinalgOp.
   OpOperand *currOpOperand = opOperand;
   while (auto linalgOp = currOpOperand->get().getDefiningOp<LinalgOp>()) {
     OpResult result = currOpOperand->get().cast<OpResult>();
     currOpOperand = linalgOp.getDpsInitOperand(result.getResultNumber());
   }
 
for (OpOperand *opOperandPtr : operandsList) {
       if (innerPackSizes.empty()) {
         inputsAndInits.push_back(operand);
         continue;
       }
       Value dest = tensor::PackOp::createDestinationTensor(
           rewriter, loc, operand, innerPackSizes, innerPos,
           /*outerDimsPerm=*/{});
       // TODO: value of the padding attribute should be determined by consumers.
-      Attribute zeroAttr =
+      auto zeroAttr =
           rewriter.getZeroAttr(getElementTypeOrSelf(dest.getType()));
       Value zero = rewriter.create<arith::ConstantOp>(loc, zeroAttr);
       packOps.push_back(rewriter.create<tensor::PackOp>(
           loc, operand, dest, innerPos, innerPackSizes, zero));
       inputsAndInits.push_back(packOps.back());
     }
   }
 

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

getReassociationMapForFoldingUnitDims(ArrayRef<OpFoldResult> mixedSizes) {
   // unit-dimensions into the last dimension.  If the reassociations so far is
   // empty, then leave it emtpy. This will fold everything to a rank-0 tensor.
   if (!curr.empty() && !reassociation.empty())
     reassociation.back().append(curr.begin(), curr.end());
   return reassociation;
 }
 
 /// Return the identity numeric value associated to the give op.
-std::optional<Attribute> getNeutralElement(Operation *op) {
+std::optional<TypedAttr> getNeutralElement(Operation *op) {
   // Builder only used as helper for attribute creation.
   OpBuilder b(op->getContext());
   Type resultType = op->getResult(0).getType();
   if (auto floatType = resultType.dyn_cast<FloatType>()) {
     const llvm::fltSemantics &semantic = floatType.getFloatSemantics();
     if (isa<arith::AddFOp>(op))
       return b.getFloatAttr(resultType, llvm::APFloat::getZero(semantic));
     if (isa<arith::MulFOp>(op))

mlir/lib/Dialect/Math/Transforms/PolynomialApproximation.cpp

CbrtApproximation::matchAndRewrite(math::CbrtOp op,
 
   Type floatTy = getElementTypeOrSelf(operand.getType());
   Type intTy = b.getIntegerType(floatTy.getIntOrFloatBitWidth());
 
   // Convert to vector types if necessary.
   floatTy = broadcast(floatTy, shape);
   intTy = broadcast(intTy, shape);
 
-  auto bconst = [&](Attribute attr) -> Value {
+  auto bconst = [&](TypedAttr attr) -> Value {
     Value value = b.create<arith::ConstantOp>(attr);
     return broadcast(b, value, shape);
   };
 
   // Declare the initial values:
   Value intTwo = bconst(b.getI32IntegerAttr(2));
   Value intFour = bconst(b.getI32IntegerAttr(4));
   Value intEight = bconst(b.getI32IntegerAttr(8));

mlir/lib/Dialect/MemRef/Transforms/ExpandOps.cpp

for (int i = rank - 1; i >= 0; --i) {
       if (op.getType().isDynamicDim(i)) {
         Value index = rewriter.create<arith::ConstantIndexOp>(loc, i);
         size = rewriter.create<memref::LoadOp>(loc, op.getShape(), index);
         if (!size.getType().isa<IndexType>())
           size = rewriter.create<arith::IndexCastOp>(
               loc, rewriter.getIndexType(), size);
         sizes[i] = size;
       } else {
-        sizes[i] = rewriter.getIndexAttr(op.getType().getDimSize(i));
-        size =
-            rewriter.create<arith::ConstantOp>(loc, sizes[i].get<Attribute>());
+        auto sizeAttr = rewriter.getIndexAttr(op.getType().getDimSize(i));
+        size = rewriter.create<arith::ConstantOp>(loc, sizeAttr);
+        sizes[i] = sizeAttr;
       }
       strides[i] = stride;
       if (i > 0)
         stride = rewriter.create<arith::MulIOp>(loc, stride, size);
     }
     rewriter.replaceOpWithNewOp<memref::ReinterpretCastOp>(
         op, op.getType(), op.getSource(), /*offset=*/rewriter.getIndexAttr(0),
         sizes, strides);

mlir/lib/Dialect/SPIRV/Transforms/SPIRVWebGPUTransforms.cpp

 //===----------------------------------------------------------------------===//
 // Helpers
 //===----------------------------------------------------------------------===//
 Attribute getScalarOrSplatAttr(Type type, int64_t value) {
   APInt sizedValue(getElementTypeOrSelf(type).getIntOrFloatBitWidth(), value);
   if (auto intTy = type.dyn_cast<IntegerType>())
     return IntegerAttr::get(intTy, sizedValue);
 
-  return SplatElementsAttr::get(type, sizedValue);
+  return SplatElementsAttr::get(cast<ShapedType>(type), sizedValue);
 }
 
 Value lowerExtendedMultiplication(Operation *mulOp, PatternRewriter &rewriter,
                                   Value lhs, Value rhs,
                                   bool signExtendArguments) {
   Location loc = mulOp->getLoc();
   Type argTy = lhs.getType();
   // Emulate 64-bit multiplication by splitting each input element of type i32

mlir/lib/Dialect/SparseTensor/Transforms/CodegenUtils.h

 
 /// Add type casting between arith and index types when needed.
 Value genCast(OpBuilder &builder, Location loc, Value value, Type dstTy);
 
 /// Generates a 1-valued attribute of the given type.  This supports
 /// all the same types as `getZeroAttr`; however, unlike `getZeroAttr`,
 /// for unsupported types we raise `llvm_unreachable` rather than
 /// returning a null attribute.
-Attribute getOneAttr(Builder &builder, Type tp);
+TypedAttr getOneAttr(Builder &builder, Type tp);
 
 /// Generates the comparison `v != 0` where `v` is of numeric type.
 /// For floating types, we use the "unordered" comparator (i.e., returns
 /// true if `v` is NaN).
 Value genIsNonzero(OpBuilder &builder, Location loc, Value v);
 
 /// Computes the shape of destination tensor of a reshape operator. This is only
 /// used when operands have dynamic shape. The shape of the destination is

mlir/lib/Dialect/SparseTensor/Transforms/CodegenUtils.cpp

Value sparse_tensor::genCast(OpBuilder &builder, Location loc, Value value,
   if (srcTp.isa<IndexType>() || dstTp.isa<IndexType>())
     return builder.create<arith::IndexCastOp>(loc, dstTp, value);
 
   const auto srcIntTp = srcTp.dyn_cast_or_null<IntegerType>();
   const bool isUnsignedCast = srcIntTp ? srcIntTp.isUnsigned() : false;
   return mlir::convertScalarToDtype(builder, loc, value, dstTp, isUnsignedCast);
 }
 
-mlir::Attribute mlir::sparse_tensor::getOneAttr(Builder &builder, Type tp) {
+mlir::TypedAttr mlir::sparse_tensor::getOneAttr(Builder &builder, Type tp) {
   if (tp.isa<FloatType>())
     return builder.getFloatAttr(tp, 1.0);
   if (tp.isa<IndexType>())
     return builder.getIndexAttr(1);
   if (auto intTp = tp.dyn_cast<IntegerType>())
     return builder.getIntegerAttr(tp, APInt(intTp.getWidth(), 1));
   if (tp.isa<RankedTensorType, VectorType>()) {
     auto shapedTp = tp.cast<ShapedType>();

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

LogicalResult matchAndRewrite(ExtractOp extractOp,
     // ConstantOp.
     Value sourceVector = extractOp.getVector();
     Attribute vectorCst;
     if (!matchPattern(sourceVector, m_Constant(&vectorCst)))
       return failure();
     auto splat = vectorCst.dyn_cast<SplatElementsAttr>();
     if (!splat)
       return failure();
-    Attribute newAttr = splat.getSplatValue<Attribute>();
+    TypedAttr newAttr = splat.getSplatValue<TypedAttr>();
     if (auto vecDstType = extractOp.getType().dyn_cast<VectorType>())
       newAttr = DenseElementsAttr::get(vecDstType, newAttr);
     rewriter.replaceOpWithNewOp<arith::ConstantOp>(extractOp, newAttr);
     return success();
   }
 };
 
 // Pattern to rewrite a ExtractOp(non-splat ConstantOp)[...] -> ConstantOp.
if (!dense || dense.isSplat())
       return failure();
 
     // Calculate the linearized position of the continuous chunk of elements to
     // extract.
     llvm::SmallVector<int64_t> completePositions(vecTy.getRank(), 0);
     copy(getI64SubArray(extractOp.getPosition()), completePositions.begin());
     int64_t elemBeginPosition =
         linearize(completePositions, computeStrides(vecTy.getShape()));
-    auto denseValuesBegin = dense.value_begin<Attribute>() + elemBeginPosition;
+    auto denseValuesBegin = dense.value_begin<TypedAttr>() + elemBeginPosition;
 
-    Attribute newAttr;
+    TypedAttr newAttr;
     if (auto resVecTy = extractOp.getType().dyn_cast<VectorType>()) {
       SmallVector<Attribute> elementValues(
           denseValuesBegin, denseValuesBegin + resVecTy.getNumElements());
       newAttr = DenseElementsAttr::get(resVecTy, elementValues);
     } else {
       newAttr = *denseValuesBegin;
     }
 

mlir/lib/Dialect/Vector/Transforms/LowerVectorMask.cpp

 /// and actually match the traits of its the nested `MaskableOpInterface`.
 template <class SourceOp>
 struct MaskOpRewritePattern : OpRewritePattern<MaskOp> {
   using OpRewritePattern<MaskOp>::OpRewritePattern;
 
 private:
   LogicalResult matchAndRewrite(MaskOp maskOp,
                                 PatternRewriter &rewriter) const final {
-    MaskableOpInterface maskableOp = maskOp.getMaskableOp();
+    auto maskableOp = cast<MaskableOpInterface>(maskOp.getMaskableOp());
     SourceOp sourceOp = dyn_cast<SourceOp>(maskableOp.getOperation());
     if (!sourceOp)
       return failure();
 
     return matchAndRewriteMaskableOp(sourceOp, maskOp, rewriter);
   }
 
 protected:

mlir/lib/Dialect/Vector/Transforms/VectorDistribute.cpp

LogicalResult matchAndRewrite(WarpExecuteOnLane0Op warpOp,
     if (!yieldOperand)
       return failure();
     auto constantOp = yieldOperand->get().getDefiningOp<arith::ConstantOp>();
     auto dense = constantOp.getValue().dyn_cast<SplatElementsAttr>();
     if (!dense)
       return failure();
     unsigned operandIndex = yieldOperand->getOperandNumber();
     Attribute scalarAttr = dense.getSplatValue<Attribute>();
-    Attribute newAttr = DenseElementsAttr::get(
-        warpOp.getResult(operandIndex).getType(), scalarAttr);
+    auto newAttr = DenseElementsAttr::get(
+        cast<ShapedType>(warpOp.getResult(operandIndex).getType()), scalarAttr);
     Location loc = warpOp.getLoc();
     rewriter.setInsertionPointAfter(warpOp);
     Value distConstant = rewriter.create<arith::ConstantOp>(loc, newAttr);
     rewriter.replaceAllUsesWith(warpOp.getResult(operandIndex), distConstant);
     return success();
   }
 };
 

mlir/lib/Dialect/X86Vector/Transforms/LegalizeForLLVMExport.cpp

matchAndRewrite(MaskCompressOp op, OpAdaptor adaptor,
 
     Value src;
     if (op.getSrc()) {
       src = adaptor.getSrc();
     } else if (op.getConstantSrc()) {
       src = rewriter.create<arith::ConstantOp>(op.getLoc(), opType,
                                                op.getConstantSrcAttr());
     } else {
-      Attribute zeroAttr = rewriter.getZeroAttr(opType);
+      auto zeroAttr = rewriter.getZeroAttr(opType);
       src = rewriter.create<arith::ConstantOp>(op->getLoc(), opType, zeroAttr);
     }
 
     rewriter.replaceOpWithNewOp<MaskCompressIntrOp>(op, opType, adaptor.getA(),
                                                     src, adaptor.getK());
 
     return success();
   }

mlir/lib/IR/Builders.cpp

 }
 
 ArrayAttr Builder::getAffineMapArrayAttr(ArrayRef<AffineMap> values) {
   auto attrs = llvm::to_vector<8>(llvm::map_range(
       values, [](AffineMap v) -> Attribute { return AffineMapAttr::get(v); }));
   return getArrayAttr(attrs);
 }
 
-Attribute Builder::getZeroAttr(Type type) {
+TypedAttr Builder::getZeroAttr(Type type) {
   if (type.isa<FloatType>())
     return getFloatAttr(type, 0.0);
   if (type.isa<IndexType>())
     return getIndexAttr(0);
   if (auto integerType = type.dyn_cast<IntegerType>())
     return getIntegerAttr(type, APInt(type.cast<IntegerType>().getWidth(), 0));
   if (type.isa<RankedTensorType, VectorType>()) {
     auto vtType = type.cast<ShapedType>();

mlir/lib/IR/BuiltinTypes.cpp

MemRefType MemRefType::get(ArrayRef<int64_t> shape, Type elementType,
                            AffineMap map, Attribute memorySpace) {
 
   // Use default layout for empty map.
   if (!map)
     map = AffineMap::getMultiDimIdentityMap(shape.size(),
                                             elementType.getContext());
 
   // Wrap AffineMap into Attribute.
-  Attribute layout = AffineMapAttr::get(map);
+  auto layout = AffineMapAttr::get(map);
 
   // Drop default memory space value and replace it with empty attribute.
   memorySpace = skipDefaultMemorySpace(memorySpace);
 
   return Base::get(elementType.getContext(), shape, elementType, layout,
                    memorySpace);
 }
 
 MemRefType
 MemRefType::getChecked(function_ref<InFlightDiagnostic()> emitErrorFn,
                        ArrayRef<int64_t> shape, Type elementType, AffineMap map,
                        Attribute memorySpace) {
 
   // Use default layout for empty map.
   if (!map)
     map = AffineMap::getMultiDimIdentityMap(shape.size(),
                                             elementType.getContext());
 
   // Wrap AffineMap into Attribute.
-  Attribute layout = AffineMapAttr::get(map);
+  auto layout = AffineMapAttr::get(map);
 
   // Drop default memory space value and replace it with empty attribute.
   memorySpace = skipDefaultMemorySpace(memorySpace);
 
   return Base::getChecked(emitErrorFn, elementType.getContext(), shape,
                           elementType, layout, memorySpace);
 }
 
 MemRefType MemRefType::get(ArrayRef<int64_t> shape, Type elementType,
                            AffineMap map, unsigned memorySpaceInd) {
 
   // Use default layout for empty map.
   if (!map)
     map = AffineMap::getMultiDimIdentityMap(shape.size(),
                                             elementType.getContext());
 
   // Wrap AffineMap into Attribute.
-  Attribute layout = AffineMapAttr::get(map);
+  auto layout = AffineMapAttr::get(map);
 
   // Convert deprecated integer-like memory space to Attribute.
   Attribute memorySpace =
       wrapIntegerMemorySpace(memorySpaceInd, elementType.getContext());
 
   return Base::get(elementType.getContext(), shape, elementType, layout,
                    memorySpace);
 }
 
 MemRefType
 MemRefType::getChecked(function_ref<InFlightDiagnostic()> emitErrorFn,
                        ArrayRef<int64_t> shape, Type elementType, AffineMap map,
                        unsigned memorySpaceInd) {
 
   // Use default layout for empty map.
   if (!map)
     map = AffineMap::getMultiDimIdentityMap(shape.size(),
                                             elementType.getContext());
 
   // Wrap AffineMap into Attribute.
-  Attribute layout = AffineMapAttr::get(map);
+  auto layout = AffineMapAttr::get(map);
 
   // Convert deprecated integer-like memory space to Attribute.
   Attribute memorySpace =
       wrapIntegerMemorySpace(memorySpaceInd, elementType.getContext());
 
   return Base::getChecked(emitErrorFn, elementType.getContext(), shape,
                           elementType, layout, memorySpace);
 }

mlir/lib/Target/SPIRV/Deserialization/Deserializer.h

private:
 
   /// Gets the composite specialization constant with the given result <id>.
   spirv::SpecConstantCompositeOp getSpecConstantComposite(uint32_t id) {
     return specConstCompositeMap.lookup(id);
   }
 
   /// Creates a spirv::SpecConstantOp.
   spirv::SpecConstantOp createSpecConstant(Location loc, uint32_t resultID,
-                                           Attribute defaultValue);
+                                           TypedAttr defaultValue);
 
   /// Processes the OpVariable instructions at current `offset` into `binary`.
   /// It is expected that this method is used for variables that are to be
   /// defined at module scope and will be deserialized into a
   /// spirv.GlobalVariable instruction.
   LogicalResult processGlobalVariable(ArrayRef<uint32_t> operands);
 
   /// Gets the global variable associated with a result <id> of OpVariable.

mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp

std::string spirv::Deserializer::getSpecConstantSymbol(uint32_t id) {
   if (constName.empty()) {
     constName = "spirv_spec_const_" + std::to_string(id);
   }
   return constName;
 }
 
 spirv::SpecConstantOp
 spirv::Deserializer::createSpecConstant(Location loc, uint32_t resultID,
-                                        Attribute defaultValue) {
+                                        TypedAttr defaultValue) {
   auto symName = opBuilder.getStringAttr(getSpecConstantSymbol(resultID));
   auto op = opBuilder.create<spirv::SpecConstantOp>(unknownLoc, symName,
                                                     defaultValue);
   if (decorations.count(resultID)) {
     for (auto attr : decorations[resultID].getAttrs())
       op->setAttr(attr.getName(), attr.getValue());
   }
   specConstMap[resultID] = op;

mlir/lib/Transforms/Utils/InliningUtils.cpp

static void handleResultImpl(InlinerInterface &interface, OpBuilder &builder,
   }
 }
 
 static LogicalResult
 inlineRegionImpl(InlinerInterface &interface, Region *src, Block *inlineBlock,
                  Block::iterator inlinePoint, IRMapping &mapper,
                  ValueRange resultsToReplace, TypeRange regionResultTypes,
                  std::optional<Location> inlineLoc,
-                 bool shouldCloneInlinedRegion, Operation *call = nullptr) {
+                 bool shouldCloneInlinedRegion, CallOpInterface call = {}) {
   assert(resultsToReplace.size() == regionResultTypes.size());
   // We expect the region to have at least one block.
   if (src->empty())
     return failure();
 
   // Check that all of the region arguments have been mapped.
   auto *srcEntryBlock = &src->front();
   if (llvm::any_of(srcEntryBlock->getArguments(),
inlineRegionImpl(InlinerInterface &interface, Region *src, Block *inlineBlock,
   firstNewBlock->erase();
   return success();
 }
 
 static LogicalResult
 inlineRegionImpl(InlinerInterface &interface, Region *src, Block *inlineBlock,
                  Block::iterator inlinePoint, ValueRange inlinedOperands,
                  ValueRange resultsToReplace, std::optional<Location> inlineLoc,
-                 bool shouldCloneInlinedRegion, Operation *call = nullptr) {
+                 bool shouldCloneInlinedRegion, CallOpInterface call = {}) {
   // We expect the region to have at least one block.
   if (src->empty())
     return failure();
 
   auto *entryBlock = &src->front();
   if (inlinedOperands.size() != entryBlock->getNumArguments())
     return failure();
 

mlir/test/lib/Dialect/Linalg/TestLinalgFusionTransforms.cpp

for (OpOperand &opOperand : linalgOp->getOpOperands()) {
         if (opOperand.getOperandNumber() >= linalgOp.getNumDpsInputs())
           continue;
         auto info = fuseProducerOfTensor(b, opOperand);
         if (failed(info))
           continue;
         auto *originalOp = info->originalProducer.getOperation();
         auto *originalOpInLinalgOpsVector =
             std::find(linalgOps.begin(), linalgOps.end(), originalOp);
-        *originalOpInLinalgOpsVector = info->fusedProducer.getOperation();
+        *originalOpInLinalgOpsVector = info->fusedProducer;
         // Don't mark for erasure in the tensor case, let DCE handle this.
         changed = true;
       }
     }
   }
   // The `fuseProducerOfBuffer` function performs structural checks and in
   // particular that no covering read or write exist between the consumer and
   // the producer. As a consequence, the only fusions that may occur preserve