[mlir] NFC - Rename OpFoldResult -> ValueOrAttr

[nicolasvasilache]

Summary

ValueOrAttr is more generally informative: this type is useful beyond folding.

[ftynse]

mlir/include/mlir/IR/OpDefinition.h

218

Please update the documentation.

I would also consider moving this into a separate file. I suppose we don't want Attribute.h to depend on Value.h or vice versa, neither do we want to include OpDefinition.h in files that are not defining ops but just want to use this utility.

[silvas]

mlir/include/mlir/IR/OpDefinition.h

218

Is the plan here that this is just a dumb union, or that it carries semantics: either a Value or an attr that needs to be materialized with an appropriate constant materialization hook (from which dialect??) into a Value.

[jpienaar]

I don't know about changing the name just because the elements the type has makes it useful in other context. In this case the name is quite descriptive for me: these are potential results from folding. E.g., IntPair vs SliceStartAndEnd, both could be a std::pair of ints, but I wouldn't rename the latter to the former to enable reuse with, say, LineAndColPair.

flang/lib/Optimizer/Dialect/FIROps.cpp

static bool verifyRecordLenParams(mlir::Type inType, unsigned numLenParams) {
   }
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // AddfOp
 //===----------------------------------------------------------------------===//
 
-mlir::OpFoldResult fir::AddfOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+mlir::ValueOrAttr fir::AddfOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
   return mlir::constFoldBinaryOp<FloatAttr>(
       opnds, [](APFloat a, APFloat b) { return a + b; });
 }
 
 //===----------------------------------------------------------------------===//
 // AllocaOp
 //===----------------------------------------------------------------------===//
 
if (intype.isa<ReferenceType>() || intype.isa<HeapType>() ||
     return {};
   return HeapType::get(intype);
 }
 
 //===----------------------------------------------------------------------===//
 // BoxAddrOp
 //===----------------------------------------------------------------------===//
 
-mlir::OpFoldResult fir::BoxAddrOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+mlir::ValueOrAttr fir::BoxAddrOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
   if (auto v = val().getDefiningOp()) {
     if (auto box = dyn_cast<fir::EmboxOp>(v))
       return box.memref();
     if (auto box = dyn_cast<fir::EmboxCharOp>(v))
       return box.memref();
   }
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // BoxCharLenOp
 //===----------------------------------------------------------------------===//
 
-mlir::OpFoldResult
+mlir::ValueOrAttr
 fir::BoxCharLenOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
   if (auto v = val().getDefiningOp()) {
     if (auto box = dyn_cast<fir::EmboxCharOp>(v))
       return box.len();
   }
   return {};
 }
 
mlir::ParseResult fir::parseCmpcOp(mlir::OpAsmParser &parser,
                                    mlir::OperationState &result) {
   return parseCmpOp<fir::CmpcOp>(parser, result);
 }
 
 //===----------------------------------------------------------------------===//
 // ConvertOp
 //===----------------------------------------------------------------------===//
 
-mlir::OpFoldResult fir::ConvertOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+mlir::ValueOrAttr fir::ConvertOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
   if (value().getType() == getType())
     return value();
   if (matchPattern(value(), m_Op<fir::ConvertOp>())) {
     auto inner = cast<fir::ConvertOp>(value().getDefiningOp());
     // (convert (convert 'a : logical -> i1) : i1 -> logical) ==> forward 'a
     if (auto toTy = getType().dyn_cast<fir::LogicalType>())
       if (auto fromTy = inner.value().getType().dyn_cast<fir::LogicalType>())
         if (inner.getType().isa<mlir::IntegerType>() && (toTy == fromTy))
for (auto op : ops)
     op->moveBefore(*this);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // MulfOp
 //===----------------------------------------------------------------------===//
 
-mlir::OpFoldResult fir::MulfOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+mlir::ValueOrAttr fir::MulfOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
   return mlir::constFoldBinaryOp<FloatAttr>(
       opnds, [](APFloat a, APFloat b) { return a * b; });
 }
 
 //===----------------------------------------------------------------------===//
 // ResultOp
 //===----------------------------------------------------------------------===//
 
bool fir::StringLitOp::isWideValue() {
   auto eleTy = getType().cast<fir::SequenceType>().getEleTy();
   return eleTy.cast<fir::CharacterType>().getFKind() != 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SubfOp
 //===----------------------------------------------------------------------===//
 
-mlir::OpFoldResult fir::SubfOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
+mlir::ValueOrAttr fir::SubfOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
   return mlir::constFoldBinaryOp<FloatAttr>(
       opnds, [](APFloat a, APFloat b) { return a - b; });
 }
 
 //===----------------------------------------------------------------------===//
 // IfOp
 //===----------------------------------------------------------------------===//
 void fir::IfOp::build(mlir::OpBuilder &builder, OperationState &result,

mlir/docs/Canonicalization.md

 ///  1. They can leave the operation alone and without changing the IR, and
 ///     return nullptr.
 ///  2. They can mutate the operation in place, without changing anything else
 ///     in the IR. In this case, return the operation itself.
 ///  3. They can return an existing value or attribute that can be used instead
 ///     of the operation. The caller will remove the operation and use that
 ///     result instead.
 ///
-OpFoldResult MyOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr MyOp::fold(ArrayRef<Attribute> operands) {
   ...
 }
 ```
 
 Otherwise, the following is generated:
 
 ```c++
 /// Implementations of this hook can only perform the following changes to the
 /// operation:
 ///
 ///  1. They can leave the operation alone and without changing the IR, and
 ///     return failure.
 ///  2. They can mutate the operation in place, without changing anything else
 ///     in the IR. In this case, return success.
 ///  3. They can return a list of existing values or attribute that can be used
 ///     instead of the operation. In this case, fill in the results list and
 ///     return success. The results list must correspond 1-1 with the results of
 ///     the operation, partial folding is not supported. The caller will remove
 ///     the operation and use those results instead.
 ///
 LogicalResult MyOp::fold(ArrayRef<Attribute> operands,
-                         SmallVectorImpl<OpFoldResult> &results) {
+                         SmallVectorImpl<ValueOrAttr> &results) {
   ...
 }
 ```
 
 In the above, for each method an `ArrayRef<Attribute>` is provided that
 corresponds to the constant attribute value of each of the operands. These
 operands are those that implement the `ConstantLike` trait. If any of the
 operands are non-constant, a null `Attribute` value is provided instead. For
 example, if MyOp provides three operands [`a`, `b`, `c`], but only `b` is
 constant then `operands` will be of the form [Attribute(), b-value,
 Attribute()].
 
-Also above, is the use of `OpFoldResult`. This class represents the possible
+Also above, is the use of `ValueOrAttr`. This class represents the possible
 result of folding an operation result: either an SSA `Value`, or an
 `Attribute`(for a constant result). If an SSA `Value` is provided, it *must*
 correspond to an existing value. The `fold` methods are not permitted to
 generate new `Value`s. There are no specific restrictions on the form of the
 `Attribute` value returned, but it is important to ensure that the `Attribute`
 representation of a specific `Type` is consistent.
 
 When the `fold` hook on an operation is not successful, the dialect can

mlir/docs/Traits.md

 and the op has a single result.
 
 ```c++
 template <typename ConcreteType>
 class MyTrait : public OpTrait::TraitBase<ConcreteType, MyTrait> {
 public:
   /// Override the 'foldTrait' hook to support trait based folding on the
   /// concrete operation.
-  static OpFoldResult foldTrait(Operation *op, ArrayRef<Attribute> operands) { {
+  static ValueOrAttr foldTrait(Operation *op, ArrayRef<Attribute> operands) { {
     // ...
   }
 };
 ```
 
 Otherwise, if the operation has a single result and the above signature is
 not implemented, or the operation has multiple results, then the following signature
 will be used (if implemented):
 
 ```c++
 template <typename ConcreteType>
 class MyTrait : public OpTrait::TraitBase<ConcreteType, MyTrait> {
 public:
   /// Override the 'foldTrait' hook to support trait based folding on the
   /// concrete operation.
   static LogicalResult foldTrait(Operation *op, ArrayRef<Attribute> operands,
-                                 SmallVectorImpl<OpFoldResult> &results) { {
+                                 SmallVectorImpl<ValueOrAttr> &results) { {
     // ...
   }
 };
 ```
 
 Note: It is generally good practice to define the implementation of the
 `foldTrait` hook out-of-line as a free function when possible to avoid
 instantiating the implementation for every concrete operation type.

mlir/docs/Tutorials/QuickstartRewrites.md

 <!-- TODO: Define a style convention. -->
 
 Operations can also have custom parser, printer, builder, verifier, constant
 folder, or canonicalizer. These require specifying additional C++ methods to
 invoke for additional functionality. For example, if an operation is marked to
 have a folder, the constant folder also needs to be added, e.g.,:
 
 ```c++
-OpFoldResult SpecificOp::fold(ArrayRef<Attribute> constOperands) {
+ValueOrAttr SpecificOp::fold(ArrayRef<Attribute> constOperands) {
   if (unable_to_fold)
     return {};
   ....
   return val;
 }
 ```
 
 ## Adding patterns

mlir/docs/Tutorials/Toy/Ch-7.md

 We have several `toy.struct_access` operations that access into a
 `toy.struct_constant`. As detailed in [chapter 3](Ch-3.md) (FoldConstantReshape),
 we can add folders for these `toy` operations by setting the `hasFolder` bit
 on the operation definition and providing a definition of the `*Op::fold`
 method.
 
 ```c++
 /// Fold constants.
-OpFoldResult ConstantOp::fold(ArrayRef<Attribute> operands) { return value(); }
+ValueOrAttr ConstantOp::fold(ArrayRef<Attribute> operands) { return value(); }
 
 /// Fold struct constants.
-OpFoldResult StructConstantOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr StructConstantOp::fold(ArrayRef<Attribute> operands) {
   return value();
 }
 
 /// Fold simple struct access operations that access into a constant.
-OpFoldResult StructAccessOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr StructAccessOp::fold(ArrayRef<Attribute> operands) {
   auto structAttr = operands.front().dyn_cast_or_null<mlir::ArrayAttr>();
   if (!structAttr)
     return nullptr;
 
   size_t elementIndex = index().getZExtValue();
   return structAttr[elementIndex];
 }
 ```

mlir/examples/toy/Ch7/mlir/ToyCombine.cpp

 using namespace toy;
 
 namespace {
 /// Include the patterns defined in the Declarative Rewrite framework.
 #include "ToyCombine.inc"
 } // end anonymous namespace
 
 /// Fold constants.
-OpFoldResult ConstantOp::fold(ArrayRef<Attribute> operands) { return value(); }
+ValueOrAttr ConstantOp::fold(ArrayRef<Attribute> operands) { return value(); }
 
 /// Fold struct constants.
-OpFoldResult StructConstantOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr StructConstantOp::fold(ArrayRef<Attribute> operands) {
   return value();
 }
 
 /// Fold simple struct access operations that access into a constant.
-OpFoldResult StructAccessOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr StructAccessOp::fold(ArrayRef<Attribute> operands) {
   auto structAttr = operands.front().dyn_cast_or_null<mlir::ArrayAttr>();
   if (!structAttr)
     return nullptr;
 
   size_t elementIndex = index();
   return structAttr[elementIndex];
 }
 

mlir/include/mlir/Dialect/Affine/IR/AffineOps.h

public:
   static StringRef getDstMapAttrName() { return "dst_map"; }
   static StringRef getTagMapAttrName() { return "tag_map"; }
 
   static StringRef getOperationName() { return "affine.dma_start"; }
   static ParseResult parse(OpAsmParser &parser, OperationState &result);
   void print(OpAsmPrinter &p);
   LogicalResult verify();
   LogicalResult fold(ArrayRef<Attribute> cstOperands,
-                     SmallVectorImpl<OpFoldResult> &results);
+                     SmallVectorImpl<ValueOrAttr> &results);
 
   /// Returns true if this DMA operation is strided, returns false otherwise.
   bool isStrided() {
     return getNumOperands() !=
            getTagMemRefOperandIndex() + 1 + getTagMap().getNumInputs() + 1;
   }
 
   /// Returns the stride value for this DMA operation.
public:
   /// Returns the number of elements transferred in the associated DMA op.
   Value getNumElements() { return getOperand(1 + getTagMap().getNumInputs()); }
 
   static StringRef getTagMapAttrName() { return "tag_map"; }
   static ParseResult parse(OpAsmParser &parser, OperationState &result);
   void print(OpAsmPrinter &p);
   LogicalResult verify();
   LogicalResult fold(ArrayRef<Attribute> cstOperands,
-                     SmallVectorImpl<OpFoldResult> &results);
+                     SmallVectorImpl<ValueOrAttr> &results);
 };
 
 /// Returns true if the given Value can be used as a dimension id in the region
 /// of the closest surrounding op that has the trait `AffineScope`.
 bool isValidDim(Value value);
 
 /// Returns true if the given Value can be used as a dimension id in `region`,
 /// i.e., for all its uses in `region`.

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td

[{
       SmallVector<int64_t, 4> staticShape(
         shape.size(), ShapedType::kDynamicSize);
       build($_builder, $_state, shape, staticShape, elementType);
     }]>,
     OpBuilderDAG<(ins "ArrayRef<int64_t>":$staticShape, "Type":$elementType),
     [{
       build($_builder, $_state, ValueRange{}, staticShape, elementType);
     }]>,
-    OpBuilderDAG<(ins "ArrayRef<OpFoldResult>":$sizes, "Type":$elementType,
+    OpBuilderDAG<(ins "ArrayRef<ValueOrAttr>":$sizes, "Type":$elementType,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 
   let hasCanonicalizer = 1;
 }
 
 def Linalg_PadTensorOp : Linalg_Op<"pad_tensor",
     [AttrSizedOperandSegments, NoSideEffect]> {
let extraClassDeclaration = [{
     // size is met).
     static linalg::PadTensorOp createPadHighOp(
         Type type, Value source, Value pad, Location loc, OpBuilder & builder);
 
     // Return a PadTensorOp that pads `source to `type` size with `pad` value.
     // I.e., a block will be created and the `pad` value will be yielded
     // directly. If the type passed is nullptr, it is inferred.
     static linalg::PadTensorOp createPadScalarOp(
-        Type type, Value source, Value pad, ArrayRef<OpFoldResult> low,
-        ArrayRef<OpFoldResult> high, Location loc, OpBuilder & builder);
+        Type type, Value source, Value pad, ArrayRef<ValueOrAttr> low,
+        ArrayRef<ValueOrAttr> high, Location loc, OpBuilder & builder);
 
     // Return a vector of all the static or dynamic values (low/high padding) of
     // the op.
-    inline SmallVector<OpFoldResult> getMixedPadImpl(ArrayAttr staticAttrs,
+    inline SmallVector<ValueOrAttr> getMixedPadImpl(ArrayAttr staticAttrs,
                                                      ValueRange values) {
-      SmallVector<OpFoldResult> res;
+      SmallVector<ValueOrAttr> res;
       unsigned numDynamic = 0;
       unsigned count = staticAttrs.size();
       for (unsigned idx = 0; idx < count; ++idx) {
         if (ShapedType::isDynamic(staticAttrs[idx].cast<IntegerAttr>().getInt()))
           res.push_back(values[numDynamic++]);
         else
           res.push_back(staticAttrs[idx]);
       }
       return res;
     }
-    SmallVector<OpFoldResult> getMixedLowPad() {
+    SmallVector<ValueOrAttr> getMixedLowPad() {
       return getMixedPadImpl(static_low(), low());
     }
-    SmallVector<OpFoldResult> getMixedHighPad() {
+    SmallVector<ValueOrAttr> getMixedHighPad() {
       return getMixedPadImpl(static_high(), high());
     }
   }];
 
   let builders = [
     // Build a PadTensorOp with mixed static and dynamic entries.
     OpBuilderDAG<(ins "Value":$source, "ArrayRef<int64_t>":$staticLow,
       "ArrayRef<int64_t>":$staticHigh, "ValueRange":$low, "ValueRange":$high,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a PadTensorOp with all dynamic entries.
     OpBuilderDAG<(ins "Value":$source, "ValueRange":$low, "ValueRange":$high,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a PadTensorOp with mixed static and dynamic entries and custom
     // result type. If the type passed is nullptr, it is inferred.
     OpBuilderDAG<(ins "Type":$resultType, "Value":$source,
-      "ArrayRef<OpFoldResult>":$low, "ArrayRef<OpFoldResult>":$high,
+      "ArrayRef<ValueOrAttr>":$low, "ArrayRef<ValueOrAttr>":$high,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 }
 
 def Linalg_RangeOp :
     Linalg_Op<"range", [NoSideEffect]>,
     Arguments<(ins Index:$min, Index:$max, Index:$step)>,
     Results<(outs Range)> {

mlir/include/mlir/Dialect/StandardOps/IR/Ops.h

public:
   }
 
   static StringRef getOperationName() { return "std.dma_start"; }
   static ParseResult parse(OpAsmParser &parser, OperationState &result);
   void print(OpAsmPrinter &p);
   LogicalResult verify();
 
   LogicalResult fold(ArrayRef<Attribute> cstOperands,
-                     SmallVectorImpl<OpFoldResult> &results);
+                     SmallVectorImpl<ValueOrAttr> &results);
 
   bool isStrided() {
     return getNumOperands() != 1 + getSrcMemRefRank() + 1 + getDstMemRefRank() +
                                    1 + 1 + getTagMemRefRank();
   }
 
   Value getStride() {
     if (!isStrided())
public:
   }
 
   // Returns the number of elements transferred in the associated DMA operation.
   Value getNumElements() { return getOperand(1 + getTagMemRefRank()); }
 
   static ParseResult parse(OpAsmParser &parser, OperationState &result);
   void print(OpAsmPrinter &p);
   LogicalResult fold(ArrayRef<Attribute> cstOperands,
-                     SmallVectorImpl<OpFoldResult> &results);
+                     SmallVectorImpl<ValueOrAttr> &results);
   LogicalResult verify();
 };
 
 /// Given an `originalShape` and a `reducedShape` assumed to be a subset of
 /// `originalShape` with some `1` entries erased, return the set of indices
 /// that specifies which of the entries of `originalShape` are dropped to obtain
 /// `reducedShape`. The returned mask can be applied as a projection to
 /// `originalShape` to obtain the `reducedShape`. This mask is useful to track

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

def MemRefReinterpretCastOp:
   }];
 
   let parser=?;
   let printer=?;
 
   let builders = [
     // Build a ReinterpretCastOp with mixed static and dynamic entries.
     OpBuilderDAG<(ins "MemRefType":$resultType, "Value":$source,
-      "OpFoldResult":$offset, "ArrayRef<OpFoldResult>":$sizes,
-      "ArrayRef<OpFoldResult>":$strides,
+      "ValueOrAttr":$offset, "ArrayRef<ValueOrAttr>":$sizes,
+      "ArrayRef<ValueOrAttr>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a ReinterpretCastOp with static entries.
     OpBuilderDAG<(ins "MemRefType":$resultType, "Value":$source,
       "int64_t":$offset, "ArrayRef<int64_t>":$sizes,
       "ArrayRef<int64_t>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a ReinterpretCastOp with dynamic entries.
     OpBuilderDAG<(ins "MemRefType":$resultType, "Value":$source,
let assemblyFormat = [{
     custom<OperandsOrIntegersSizesList>($sizes, $static_sizes)
     custom<OperandsOrIntegersOffsetsOrStridesList>($strides, $static_strides)
     attr-dict `:` type($source) `to` type($result)
   }];
 
   let builders = [
     // Build a SubViewOp with mixed static and dynamic entries and custom
     // result type. If the type passed is nullptr, it is inferred.
-    OpBuilderDAG<(ins "Value":$source, "ArrayRef<OpFoldResult>":$offsets,
-      "ArrayRef<OpFoldResult>":$sizes, "ArrayRef<OpFoldResult>":$strides,
+    OpBuilderDAG<(ins "Value":$source, "ArrayRef<ValueOrAttr>":$offsets,
+      "ArrayRef<ValueOrAttr>":$sizes, "ArrayRef<ValueOrAttr>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubViewOp with mixed static and dynamic entries and inferred
     // result type.
     OpBuilderDAG<(ins "MemRefType":$resultType, "Value":$source,
-      "ArrayRef<OpFoldResult>":$offsets, "ArrayRef<OpFoldResult>":$sizes,
-      "ArrayRef<OpFoldResult>":$strides,
+      "ArrayRef<ValueOrAttr>":$offsets, "ArrayRef<ValueOrAttr>":$sizes,
+      "ArrayRef<ValueOrAttr>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubViewOp with static entries and custom result type. If the
     // type passed is nullptr, it is inferred.
     OpBuilderDAG<(ins "Value":$source, "ArrayRef<int64_t>":$offsets,
       "ArrayRef<int64_t>":$sizes, "ArrayRef<int64_t>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubViewOp with static entries and inferred result type.
     OpBuilderDAG<(ins "MemRefType":$resultType, "Value":$source,
let extraClassDeclaration = extraBaseClassDeclaration # [{
     /// A subview result type can be fully inferred from the source type and the
     /// static representation of offsets, sizes and strides. Special sentinels
     /// encode the dynamic case.
     static Type inferResultType(MemRefType sourceMemRefType,
                                 ArrayRef<int64_t> staticOffsets,
                                 ArrayRef<int64_t> staticSizes,
                                 ArrayRef<int64_t> staticStrides);
     static Type inferResultType(MemRefType sourceMemRefType,
-                                ArrayRef<OpFoldResult> staticOffsets,
-                                ArrayRef<OpFoldResult> staticSizes,
-                                ArrayRef<OpFoldResult> staticStrides);
+                                ArrayRef<ValueOrAttr> staticOffsets,
+                                ArrayRef<ValueOrAttr> staticSizes,
+                                ArrayRef<ValueOrAttr> staticStrides);
 
     /// Return the expected rank of each of the`static_offsets`, `static_sizes`
     /// and `static_strides` attributes.
     std::array<unsigned, 3> getArrayAttrMaxRanks() {
       unsigned rank = getSourceType().getRank();
       return {rank, rank, rank};
     }
 
let assemblyFormat = [{
     custom<OperandsOrIntegersSizesList>($sizes, $static_sizes)
     custom<OperandsOrIntegersOffsetsOrStridesList>($strides, $static_strides)
     attr-dict `:` type($source) `to` type($result)
   }];
 
   let builders = [
     // Build a SubTensorOp with mixed static and dynamic entries and inferred
     // result type.
-    OpBuilderDAG<(ins "Value":$source, "ArrayRef<OpFoldResult>":$offsets,
-      "ArrayRef<OpFoldResult>":$sizes, "ArrayRef<OpFoldResult>":$strides,
+    OpBuilderDAG<(ins "Value":$source, "ArrayRef<ValueOrAttr>":$offsets,
+      "ArrayRef<ValueOrAttr>":$sizes, "ArrayRef<ValueOrAttr>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubTensorOp with mixed static and dynamic entries and custom
     // result type. If the type passed is nullptr, it is inferred.
     OpBuilderDAG<(ins "RankedTensorType":$resultType, "Value":$source,
-      "ArrayRef<OpFoldResult>":$offsets, "ArrayRef<OpFoldResult>":$sizes,
-      "ArrayRef<OpFoldResult>":$strides,
+      "ArrayRef<ValueOrAttr>":$offsets, "ArrayRef<ValueOrAttr>":$sizes,
+      "ArrayRef<ValueOrAttr>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubTensorOp with dynamic entries and custom result type. If the
     // type passed is nullptr, it is inferred.
     OpBuilderDAG<(ins "Value":$source, "ValueRange":$offsets,
       "ValueRange":$sizes, "ValueRange":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubTensorOp with dynamic entries and inferred result type.
     OpBuilderDAG<(ins "RankedTensorType":$resultType, "Value":$source,
let extraClassDeclaration = extraBaseClassDeclaration # [{
     /// A subtensor result type can be fully inferred from the source type and
     /// the static representation of offsets, sizes and strides. Special
     /// sentinels encode the dynamic case.
     static Type inferResultType(RankedTensorType sourceRankedTensorType,
                                 ArrayRef<int64_t> staticOffsets,
                                 ArrayRef<int64_t> staticSizes,
                                 ArrayRef<int64_t> staticStrides);
     static Type inferResultType(RankedTensorType sourceRankedTensorType,
-                                ArrayRef<OpFoldResult> staticOffsets,
-                                ArrayRef<OpFoldResult> staticSizes,
-                                ArrayRef<OpFoldResult> staticStrides);
+                                ArrayRef<ValueOrAttr> staticOffsets,
+                                ArrayRef<ValueOrAttr> staticSizes,
+                                ArrayRef<ValueOrAttr> staticStrides);
 
     /// Return the expected rank of each of the`static_offsets`, `static_sizes`
     /// and `static_strides` attributes.
     std::array<unsigned, 3> getArrayAttrMaxRanks() {
       unsigned rank = getSourceType().getRank();
       return {rank, rank, rank};
     }
 
let assemblyFormat = [{
     attr-dict `:` type($source) `into` type($dest)
   }];
 
   let verifier = ?;
 
   let builders = [
     // Build a SubTensorInsertOp with mixed static and dynamic entries.
     OpBuilderDAG<(ins "Value":$source, "Value":$dest,
-      "ArrayRef<OpFoldResult>":$offsets, "ArrayRef<OpFoldResult>":$sizes,
-      "ArrayRef<OpFoldResult>":$strides,
+      "ArrayRef<ValueOrAttr>":$offsets, "ArrayRef<ValueOrAttr>":$sizes,
+      "ArrayRef<ValueOrAttr>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubTensorInsertOp with dynamic entries.
     OpBuilderDAG<(ins "Value":$source, "Value":$dest,
       "ValueRange":$offsets, "ValueRange":$sizes, "ValueRange":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = extraBaseClassDeclaration # [{

mlir/include/mlir/IR/Matchers.h

template <typename AttrT> struct constant_op_binder {
   /// Creates a matcher instance that doesn't bind if match succeeds.
   constant_op_binder() : bind_value(nullptr) {}
 
   bool match(Operation *op) {
     if (!op->hasTrait<OpTrait::ConstantLike>())
       return false;
 
     // Fold the constant to an attribute.
-    SmallVector<OpFoldResult, 1> foldedOp;
+    SmallVector<ValueOrAttr, 1> foldedOp;
     LogicalResult result = op->fold(/*operands=*/llvm::None, foldedOp);
     (void)result;
     assert(succeeded(result) && "expected ConstantLike op to be foldable");
 
     if (auto attr = foldedOp.front().get<Attribute>().dyn_cast<AttrT>()) {
       if (bind_value)
         *bind_value = attr;
       return true;

mlir/include/mlir/IR/OpDefinition.h

 // Allow comparing operators.
 inline bool operator==(OpState lhs, OpState rhs) {
   return lhs.getOperation() == rhs.getOperation();
 }
 inline bool operator!=(OpState lhs, OpState rhs) {
   return lhs.getOperation() != rhs.getOperation();
 }
 
-raw_ostream &operator<<(raw_ostream &os, OpFoldResult ofr);
+raw_ostream &operator<<(raw_ostream &os, ValueOrAttr ofr);
 
 /// This class represents a single result from folding an operation.
-class OpFoldResult : public PointerUnion<Attribute, Value> {
+class ValueOrAttr : public PointerUnion<Attribute, Value> {
   using PointerUnion<Attribute, Value>::PointerUnion;
 
 public:
   void dump() { llvm::errs() << *this << "\n"; }
 };
 
 /// Allow printing to a stream.
-inline raw_ostream &operator<<(raw_ostream &os, OpFoldResult ofr) {
+inline raw_ostream &operator<<(raw_ostream &os, ValueOrAttr ofr) {
   if (Value value = ofr.dyn_cast<Value>())
     value.print(os);
   else
     ofr.dyn_cast<Attribute>().print(os);
   return os;
 }
 
 /// Allow printing to a stream.
 inline raw_ostream &operator<<(raw_ostream &os, OpState &op) {
   op.print(os, OpPrintingFlags().useLocalScope());
   return os;
 }
 
 //===----------------------------------------------------------------------===//
 // Operation Trait Types
 //===----------------------------------------------------------------------===//
 
 namespace OpTrait {
 
 // These functions are out-of-line implementations of the methods in the
 // corresponding trait classes.  This avoids them being template
 // instantiated/duplicated.
 namespace impl {
-OpFoldResult foldIdempotent(Operation *op);
-OpFoldResult foldInvolution(Operation *op);
+ValueOrAttr foldIdempotent(Operation *op);
+ValueOrAttr foldInvolution(Operation *op);
 LogicalResult verifyZeroOperands(Operation *op);
 LogicalResult verifyOneOperand(Operation *op);
 LogicalResult verifyNOperands(Operation *op, unsigned numOperands);
 LogicalResult verifyIsIdempotent(Operation *op);
 LogicalResult verifyIsInvolution(Operation *op);
 LogicalResult verifyAtLeastNOperands(Operation *op, unsigned numOperands);
 LogicalResult verifyOperandsAreFloatLike(Operation *op);
 LogicalResult verifyOperandsAreSignlessIntegerLike(Operation *op);
static_assert(ConcreteType::template hasTrait<OneOperand>(),
                   "expected operation to take one operand");
     static_assert(ConcreteType::template hasTrait<SameOperandsAndResultType>(),
                   "expected operation to preserve type");
     // Involution requires the operation to be side effect free as well
     // but currently this check is under a FIXME and is not actually done.
     return impl::verifyIsInvolution(op);
   }
 
-  static OpFoldResult foldTrait(Operation *op, ArrayRef<Attribute> operands) {
+  static ValueOrAttr foldTrait(Operation *op, ArrayRef<Attribute> operands) {
     return impl::foldInvolution(op);
   }
 };
 
 /// This class adds property that the operation is idempotent.
 /// This means a unary to unary operation "f" that satisfies f(f(x)) = f(x)
 template <typename ConcreteType>
 class IsIdempotent : public TraitBase<ConcreteType, IsIdempotent> {
 public:
   static LogicalResult verifyTrait(Operation *op) {
     static_assert(ConcreteType::template hasTrait<OneResult>(),
                   "expected operation to produce one result");
     static_assert(ConcreteType::template hasTrait<OneOperand>(),
                   "expected operation to take one operand");
     static_assert(ConcreteType::template hasTrait<SameOperandsAndResultType>(),
                   "expected operation to preserve type");
     // Idempotent requires the operation to be side effect free as well
     // but currently this check is under a FIXME and is not actually done.
     return impl::verifyIsIdempotent(op);
   }
 
-  static OpFoldResult foldTrait(Operation *op, ArrayRef<Attribute> operands) {
+  static ValueOrAttr foldTrait(Operation *op, ArrayRef<Attribute> operands) {
     return impl::foldIdempotent(op);
   }
 };
 
 /// This class verifies that all operands of the specified op have a float type,
 /// a vector thereof, or a tensor thereof.
 template <typename ConcreteType>
 class OperandsAreFloatLike

 template <typename T>
 using detect_has_single_result_fold_trait =
     llvm::is_detected<has_single_result_fold_trait, T>;
 /// Trait to check if T provides a general 'foldTrait' method.
 template <typename T, typename... Args>
 using has_fold_trait =
     decltype(T::foldTrait(std::declval<Operation *>(),
                           std::declval<ArrayRef<Attribute>>(),
-                          std::declval<SmallVectorImpl<OpFoldResult> &>()));
+                          std::declval<SmallVectorImpl<ValueOrAttr> &>()));
 template <typename T>
 using detect_has_fold_trait = llvm::is_detected<has_fold_trait, T>;
 /// Trait to check if T provides any `foldTrait` method.
 /// NOTE: This should use std::disjunction when C++17 is available.
 template <typename T>
 using detect_has_any_fold_trait =
     std::conditional_t<bool(detect_has_fold_trait<T>::value),
                        detect_has_fold_trait<T>,
                        detect_has_single_result_fold_trait<T>>;
 
 /// Returns the result of folding a trait that implements a `foldTrait` function
 /// that is specialized for operations that have a single result.
 template <typename Trait>
 static std::enable_if_t<detect_has_single_result_fold_trait<Trait>::value,
                         LogicalResult>
 foldTrait(Operation *op, ArrayRef<Attribute> operands,
-          SmallVectorImpl<OpFoldResult> &results) {
+          SmallVectorImpl<ValueOrAttr> &results) {
   assert(op->hasTrait<OpTrait::OneResult>() &&
          "expected trait on non single-result operation to implement the "
          "general `foldTrait` method");
   // If a previous trait has already been folded and replaced this operation, we
   // fail to fold this trait.
   if (!results.empty())
     return failure();
 
-  if (OpFoldResult result = Trait::foldTrait(op, operands)) {
+  if (ValueOrAttr result = Trait::foldTrait(op, operands)) {
     if (result.template dyn_cast<Value>() != op->getResult(0))
       results.push_back(result);
     return success();
   }
   return failure();
 }
 /// Returns the result of folding a trait that implements a generalized
 /// `foldTrait` function that is supports any operation type.
 template <typename Trait>
 static std::enable_if_t<detect_has_fold_trait<Trait>::value, LogicalResult>
 foldTrait(Operation *op, ArrayRef<Attribute> operands,
-          SmallVectorImpl<OpFoldResult> &results) {
+          SmallVectorImpl<ValueOrAttr> &results) {
   // If a previous trait has already been folded and replaced this operation, we
   // fail to fold this trait.
   return results.empty() ? Trait::foldTrait(op, operands, results) : failure();
 }
 
 /// The internal implementation of `foldTraits` below that returns the result of
 /// folding a set of trait types `Ts` that implement a `foldTrait` method.
 template <typename... Ts>
 static LogicalResult foldTraitsImpl(Operation *op, ArrayRef<Attribute> operands,
-                                    SmallVectorImpl<OpFoldResult> &results,
+                                    SmallVectorImpl<ValueOrAttr> &results,
                                     std::tuple<Ts...> *) {
   bool anyFolded = false;
   (void)std::initializer_list<int>{
       (anyFolded |= succeeded(foldTrait<Ts>(op, operands, results)), 0)...};
   return success(anyFolded);
 }
 
 /// Given a tuple type containing a set of traits that contain a `foldTrait`
 /// method, return the result of folding the given operation.
 template <typename TraitTupleT>
 static std::enable_if_t<std::tuple_size<TraitTupleT>::value != 0, LogicalResult>
 foldTraits(Operation *op, ArrayRef<Attribute> operands,
-           SmallVectorImpl<OpFoldResult> &results) {
+           SmallVectorImpl<ValueOrAttr> &results) {
   return foldTraitsImpl(op, operands, results, (TraitTupleT *)nullptr);
 }
 /// A variant of the method above that is specialized when there are no traits
 /// that contain a `foldTrait` method.
 template <typename TraitTupleT>
 static std::enable_if_t<std::tuple_size<TraitTupleT>::value == 0, LogicalResult>
 foldTraits(Operation *op, ArrayRef<Attribute> operands,
-           SmallVectorImpl<OpFoldResult> &results) {
+           SmallVectorImpl<ValueOrAttr> &results) {
   return failure();
 }
 
 //===----------------------------------------------------------------------===//
 // Trait Verification
 
 /// Trait to check if T provides a `verifyTrait` method.
 template <typename T, typename... Args>
private:
   template <typename T, typename... Args>
   using has_single_result_fold =
       decltype(std::declval<T>().fold(std::declval<ArrayRef<Attribute>>()));
   template <typename T>
   using detect_has_single_result_fold =
       llvm::is_detected<has_single_result_fold, T>;
   /// Trait to check if T provides a general 'fold' method.
   template <typename T, typename... Args>
-  using has_fold = decltype(
-      std::declval<T>().fold(std::declval<ArrayRef<Attribute>>(),
-                             std::declval<SmallVectorImpl<OpFoldResult> &>()));
+  using has_fold = decltype(std::declval<T>().fold(
+      std::declval<ArrayRef<Attribute>>(),
+      std::declval<SmallVectorImpl<ValueOrAttr> &>()));
   template <typename T>
   using detect_has_fold = llvm::is_detected<has_fold, T>;
   /// Trait to check if T provides a 'print' method.
   template <typename T, typename... Args>
   using has_print =
       decltype(std::declval<T>().print(std::declval<OpAsmPrinter &>()));
   template <typename T>
   using detect_has_print = llvm::is_detected<has_print, T>;
getFoldHookFnImpl() {
     // In this case, we only need to fold the traits of the operation.
     return &op_definition_impl::foldTraits<FoldableTraitsTupleT>;
   }
   /// Return the result of folding a single result operation that defines a
   /// `fold` method.
   template <typename ConcreteOpT>
   static LogicalResult
   foldSingleResultHook(Operation *op, ArrayRef<Attribute> operands,
-                       SmallVectorImpl<OpFoldResult> &results) {
-    OpFoldResult result = cast<ConcreteOpT>(op).fold(operands);
+                       SmallVectorImpl<ValueOrAttr> &results) {
+    ValueOrAttr result = cast<ConcreteOpT>(op).fold(operands);
 
     // If the fold failed or was in-place, try to fold the traits of the
     // operation.
     if (!result || result.template dyn_cast<Value>() == op->getResult(0)) {
       if (succeeded(op_definition_impl::foldTraits<FoldableTraitsTupleT>(
               op, operands, results)))
         return success();
       return success(static_cast<bool>(result));
     }
     results.push_back(result);
     return success();
   }
   /// Return the result of folding an operation that defines a `fold` method.
   template <typename ConcreteOpT>
   static LogicalResult foldHook(Operation *op, ArrayRef<Attribute> operands,
-                                SmallVectorImpl<OpFoldResult> &results) {
+                                SmallVectorImpl<ValueOrAttr> &results) {
     LogicalResult result = cast<ConcreteOpT>(op).fold(operands, results);
 
     // If the fold failed or was in-place, try to fold the traits of the
     // operation.
     if (failed(result) || results.empty()) {
       if (succeeded(op_definition_impl::foldTraits<FoldableTraitsTupleT>(
               op, operands, results)))
         return success();

 } // namespace impl
 
 // These functions are out-of-line implementations of the methods in
 // CastOpInterface, which avoids them being template instantiated/duplicated.
 namespace impl {
 /// Attempt to fold the given cast operation.
 LogicalResult foldCastInterfaceOp(Operation *op,
                                   ArrayRef<Attribute> attrOperands,
-                                  SmallVectorImpl<OpFoldResult> &foldResults);
+                                  SmallVectorImpl<ValueOrAttr> &foldResults);
 /// Attempt to verify the given cast operation.
 LogicalResult verifyCastInterfaceOp(
     Operation *op, function_ref<bool(TypeRange, TypeRange)> areCastCompatible);
 
 // TODO: Remove the parse/print/build here (new ODS functionality obsoletes the
 // need for them, but some older ODS code in `std` still depends on them).
 void buildCastOp(OpBuilder &builder, OperationState &result, Value source,
                  Type destType);

mlir/include/mlir/IR/Operation.h

public:
   // Accessors for various properties of operations
   //===--------------------------------------------------------------------===//
 
   /// Attempt to fold this operation with the specified constant operand values
   /// - the elements in "operands" will correspond directly to the operands of
   /// the operation, but may be null if non-constant. If folding is successful,
   /// this fills in the `results` vector. If not, `results` is unspecified.
   LogicalResult fold(ArrayRef<Attribute> operands,
-                     SmallVectorImpl<OpFoldResult> &results);
+                     SmallVectorImpl<ValueOrAttr> &results);
 
   /// Returns true if the operation was registered with a particular trait, e.g.
   /// hasTrait<OperandsAreSignlessIntegerLike>().
   template <template <typename T> class Trait> bool hasTrait() {
     const AbstractOperation *abstractOp = getAbstractOperation();
     return abstractOp ? abstractOp->hasTrait<Trait>() : false;
   }
 

mlir/include/mlir/IR/OperationSupport.h

 class DictionaryAttr;
 class ElementsAttr;
 class Operation;
 struct OperationState;
 class OpAsmParser;
 class OpAsmParserResult;
 class OpAsmPrinter;
 class OperandRange;
-class OpFoldResult;
+class ValueOrAttr;
 class ParseResult;
 class Pattern;
 class Region;
 class ResultRange;
 class RewritePattern;
 class Type;
 class Value;
 class ValueRange;

 /// should only be used by things like the AsmPrinter and other things that need
 /// to be parameterized by generic operation hooks.  Most user code should use
 /// the concrete operation types.
 class AbstractOperation {
 public:
   using GetCanonicalizationPatternsFn = void (*)(OwningRewritePatternList &,
                                                  MLIRContext *);
   using FoldHookFn = LogicalResult (*)(Operation *, ArrayRef<Attribute>,
-                                       SmallVectorImpl<OpFoldResult> &);
+                                       SmallVectorImpl<ValueOrAttr> &);
   using HasTraitFn = bool (*)(TypeID);
   using ParseAssemblyFn = ParseResult (*)(OpAsmParser &, OperationState &);
   using PrintAssemblyFn = void (*)(Operation *, OpAsmPrinter &);
   using VerifyInvariantsFn = LogicalResult (*)(Operation *);
 
   /// This is the name of the operation.
   const Identifier name;
 
public:
   ///     the operation.  In this case, fill in the results list and return
   ///     success.  The caller will remove the operation and use those results
   ///     instead.
   ///
   /// This allows expression of some simple in-place canonicalizations (e.g.
   /// "x+0 -> x", "min(x,y,x,z) -> min(x,y,z)", "x+y-x -> y", etc), as well as
   /// generalized constant folding.
   LogicalResult foldHook(Operation *op, ArrayRef<Attribute> operands,
-                         SmallVectorImpl<OpFoldResult> &results) const {
+                         SmallVectorImpl<ValueOrAttr> &results) const {
     return foldHookFn(op, operands, results);
   }
 
   /// This hook returns any canonicalization pattern rewrites that the operation
   /// supports, for use by the canonicalization pass.
   void getCanonicalizationPatterns(OwningRewritePatternList &results,
                                    MLIRContext *context) const {
     return getCanonicalizationPatternsFn(results, context);

mlir/include/mlir/Interfaces/CastInterfaces.td

StaticInterfaceMethod<[{
       "bool", "areCastCompatible",
       (ins "mlir::TypeRange":$inputs, "mlir::TypeRange":$outputs)
     >,
   ];
 
   let extraTraitClassDeclaration = [{
     /// Attempt to fold the given cast operation.
     static LogicalResult foldTrait(Operation *op, ArrayRef<Attribute> operands,
-                                   SmallVectorImpl<OpFoldResult> &results) {
+                                   SmallVectorImpl<ValueOrAttr> &results) {
       return impl::foldCastInterfaceOp(op, operands, results);
     }
   }];
   let verify = [{
     return impl::verifyCastInterfaceOp($_op, ConcreteOp::areCastCompatible);
   }];
 }
 
 #endif // MLIR_INTERFACES_CASTINTERFACES

mlir/include/mlir/Interfaces/FoldInterfaces.h

 //===- FoldInterfaces.h - Folding Interfaces --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_INTERFACES_FOLDINTERFACES_H_
 #define MLIR_INTERFACES_FOLDINTERFACES_H_
 
 #include "mlir/IR/DialectInterface.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace mlir {
 class Attribute;
-class OpFoldResult;
+class ValueOrAttr;
 class Region;
 
 /// Define a fold interface to allow for dialects to control specific aspects
 /// of the folding behavior for operations they define.
 class DialectFoldInterface
     : public DialectInterface::Base<DialectFoldInterface> {
 public:
   DialectFoldInterface(Dialect *dialect) : Base(dialect) {}
 
   /// Registered fallback fold for the dialect. Like the fold hook of each
   /// operation, it attempts to fold the operation with the specified constant
   /// operand values - the elements in "operands" will correspond directly to
   /// the operands of the operation, but may be null if non-constant.  If
   /// folding is successful, this fills in the `results` vector.  If not, this
   /// returns failure and `results` is unspecified.
   virtual LogicalResult fold(Operation *op, ArrayRef<Attribute> operands,
-                             SmallVectorImpl<OpFoldResult> &results) const {
+                             SmallVectorImpl<ValueOrAttr> &results) const {
     return failure();
   }
 
   /// Registered hook to check if the given region, which is attached to an
   /// operation that is *not* isolated from above, should be used when
   /// materializing constants. The folder will generally materialize constants
   /// into the top-level isolated region, this allows for materializing into a
   /// lower level ancestor region if it is more profitable/correct.
   virtual bool shouldMaterializeInto(Region *region) const { return false; }
 };
 
 } // end namespace mlir
 
 #endif // MLIR_INTERFACES_FOLDINTERFACES_H_

mlir/include/mlir/Interfaces/ViewLikeInterface.td

InterfaceMethod<
       /*defaultImplementation=*/[{
         return $_op.static_strides();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return a vector of all the static or dynamic sizes of the op.
       }],
-      /*retTy=*/"::mlir::SmallVector<::mlir::OpFoldResult, 4>",
+      /*retTy=*/"::mlir::SmallVector<::mlir::ValueOrAttr, 4>",
       /*methodName=*/"getMixedOffsets",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        ::mlir::SmallVector<::mlir::OpFoldResult, 4> res;
+        ::mlir::SmallVector<::mlir::ValueOrAttr, 4> res;
         unsigned numDynamic = 0;
         unsigned count = $_op.static_offsets().size();
         for (unsigned idx = 0; idx < count; ++idx) {
           if (isDynamicOffset(idx))
             res.push_back($_op.offsets()[numDynamic++]);
           else
             res.push_back($_op.static_offsets()[idx]);
         }
         return res;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return a vector of all the static or dynamic sizes of the op.
       }],
-      /*retTy=*/"::mlir::SmallVector<::mlir::OpFoldResult, 4>",
+      /*retTy=*/"::mlir::SmallVector<::mlir::ValueOrAttr, 4>",
       /*methodName=*/"getMixedSizes",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        ::mlir::SmallVector<::mlir::OpFoldResult, 4> res;
+        ::mlir::SmallVector<::mlir::ValueOrAttr, 4> res;
         unsigned numDynamic = 0;
         unsigned count = $_op.static_sizes().size();
         for (unsigned idx = 0; idx < count; ++idx) {
           if (isDynamicSize(idx))
             res.push_back($_op.sizes()[numDynamic++]);
           else
             res.push_back($_op.static_sizes()[idx]);
         }
         return res;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return a vector of all the static or dynamic strides of the op.
       }],
-      /*retTy=*/"::mlir::SmallVector<::mlir::OpFoldResult, 4>",
+      /*retTy=*/"::mlir::SmallVector<::mlir::ValueOrAttr, 4>",
       /*methodName=*/"getMixedStrides",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        ::mlir::SmallVector<::mlir::OpFoldResult, 4> res;
+        ::mlir::SmallVector<::mlir::ValueOrAttr, 4> res;
         unsigned numDynamic = 0;
         unsigned count = $_op.static_strides().size();
         for (unsigned idx = 0; idx < count; ++idx) {
           if (isDynamicStride(idx))
             res.push_back($_op.strides()[numDynamic++]);
           else
             res.push_back($_op.static_strides()[idx]);
         }

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

if (!ShapedType::isDynamicStrideOrOffset(offset)) {
       Value baseOffset = sourceMemRef.offset(rewriter, loc);
       // `inferredShapeRank` may be larger than the number of offset operands
       // because of trailing semantics. In this case, the offset is guaranteed
       // to be interpreted as 0 and we can just skip the extra dimensions.
       for (unsigned i = 0, e = std::min(inferredShapeRank,
                                         subViewOp.getMixedOffsets().size());
            i < e; ++i) {
         Value offset =
-            // TODO: need OpFoldResult ODS adaptor to clean this up.
+            // TODO: need ValueOrAttr ODS adaptor to clean this up.
             subViewOp.isDynamicOffset(i)
                 ? operands[subViewOp.getIndexOfDynamicOffset(i)]
                 : rewriter.create<LLVM::ConstantOp>(
                       loc, llvmIndexType,
                       rewriter.getI64IntegerAttr(subViewOp.getStaticOffset(i)));
         Value mul = rewriter.create<LLVM::MulOp>(loc, offset, strideValues[i]);
         baseOffset = rewriter.create<LLVM::AddOp>(loc, baseOffset, mul);
       }
       targetMemRef.setOffset(rewriter, loc, baseOffset);
     }
 
     // Update sizes and strides.
-    SmallVector<OpFoldResult> mixedSizes = subViewOp.getMixedSizes();
-    SmallVector<OpFoldResult> mixedStrides = subViewOp.getMixedStrides();
+    SmallVector<ValueOrAttr> mixedSizes = subViewOp.getMixedSizes();
+    SmallVector<ValueOrAttr> mixedStrides = subViewOp.getMixedStrides();
     assert(mixedSizes.size() == mixedStrides.size() &&
            "expected sizes and strides of equal length");
     for (int i = inferredShapeRank - 1, j = resultShapeRank - 1;
          i >= 0 && j >= 0; --i) {
       if (unusedDims.contains(i))
         continue;
 
       // `i` may overflow subViewOp.getMixedSizes because of trailing semantics.
       // In this case, the size is guaranteed to be interpreted as Dim and the
       // stride as 1.
       Value size, stride;
       if (static_cast<unsigned>(i) >= mixedSizes.size()) {
         size = rewriter.create<LLVM::DialectCastOp>(
             loc, llvmIndexType,
             rewriter.create<DimOp>(loc, subViewOp.source(), i));
         stride = rewriter.create<LLVM::ConstantOp>(
             loc, llvmIndexType, rewriter.getI64IntegerAttr(1));
       } else {
-        // TODO: need OpFoldResult ODS adaptor to clean this up.
+        // TODO: need ValueOrAttr ODS adaptor to clean this up.
         size =
             subViewOp.isDynamicSize(i)
                 ? operands[subViewOp.getIndexOfDynamicSize(i)]
                 : rewriter.create<LLVM::ConstantOp>(
                       loc, llvmIndexType,
                       rewriter.getI64IntegerAttr(subViewOp.getStaticSize(i)));
         if (!ShapedType::isDynamicStrideOrOffset(strides[i])) {
           stride = rewriter.create<LLVM::ConstantOp>(

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

 // The result of the affine apply operation can be used as a symbol in `region`
 // if all its operands are symbols in `region`.
 bool AffineApplyOp::isValidSymbol(Region *region) {
   return llvm::all_of(getOperands(), [&](Value operand) {
     return mlir::isValidSymbol(operand, region);
   });
 }
 
-OpFoldResult AffineApplyOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr AffineApplyOp::fold(ArrayRef<Attribute> operands) {
   auto map = getAffineMap();
 
   // Fold dims and symbols to existing values.
   auto expr = map.getResult(0);
   if (auto dim = expr.dyn_cast<AffineDimExpr>())
     return getOperand(dim.getPosition());
   if (auto sym = expr.dyn_cast<AffineSymbolExpr>())
     return getOperand(map.getNumDims() + sym.getPosition());
if (!idx.getType().isIndex())
       return emitOpError("tag index to dma_start must have 'index' type");
     if (!isValidAffineIndexOperand(idx, scope))
       return emitOpError("tag index must be a dimension or symbol identifier");
   }
   return success();
 }
 
 LogicalResult AffineDmaStartOp::fold(ArrayRef<Attribute> cstOperands,
-                                     SmallVectorImpl<OpFoldResult> &results) {
+                                     SmallVectorImpl<ValueOrAttr> &results) {
   /// dma_start(memrefcast) -> dma_start
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // AffineDmaWaitOp
 //===----------------------------------------------------------------------===//
 
if (!idx.getType().isIndex())
       return emitOpError("index to dma_wait must have 'index' type");
     if (!isValidAffineIndexOperand(idx, scope))
       return emitOpError("index must be a dimension or symbol identifier");
   }
   return success();
 }
 
 LogicalResult AffineDmaWaitOp::fold(ArrayRef<Attribute> cstOperands,
-                                    SmallVectorImpl<OpFoldResult> &results) {
+                                    SmallVectorImpl<ValueOrAttr> &results) {
   /// dma_wait(memrefcast) -> dma_wait
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // AffineForOp
 //===----------------------------------------------------------------------===//
 

 } // end anonymous namespace
 
 void AffineForOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                               MLIRContext *context) {
   results.insert<AffineForEmptyLoopFolder>(context);
 }
 
 LogicalResult AffineForOp::fold(ArrayRef<Attribute> operands,
-                                SmallVectorImpl<OpFoldResult> &results) {
+                                SmallVectorImpl<ValueOrAttr> &results) {
   bool folded = succeeded(foldLoopBounds(*this));
   folded |= succeeded(canonicalizeLoopBounds(*this));
   return success(folded);
 }
 
 AffineBound AffineForOp::getLowerBound() {
   auto lbMap = getLowerBoundMap();
   return AffineBound(AffineForOp(*this), 0, lbMap.getNumInputs(), lbMap);

 void AffineIfOp::build(OpBuilder &builder, OperationState &result,
                        IntegerSet set, ValueRange args, bool withElseRegion) {
   AffineIfOp::build(builder, result, /*resultTypes=*/{}, set, args,
                     withElseRegion);
 }
 
 /// Canonicalize an affine if op's conditional (integer set + operands).
 LogicalResult AffineIfOp::fold(ArrayRef<Attribute>,
-                               SmallVectorImpl<OpFoldResult> &) {
+                               SmallVectorImpl<ValueOrAttr> &) {
   auto set = getIntegerSet();
   SmallVector<Value, 4> operands(getOperands());
   canonicalizeSetAndOperands(&set, &operands);
 
   // Any canonicalization change always leads to either a reduction in the
   // number of operands or a change in the number of symbolic operands
   // (promotion of dims to symbols).
   if (operands.size() < getIntegerSet().getNumInputs() ||
LogicalResult verify(AffineLoadOp op) {
   return success();
 }
 
 void AffineLoadOp::getCanonicalizationPatterns(
     OwningRewritePatternList &results, MLIRContext *context) {
   results.insert<SimplifyAffineOp<AffineLoadOp>>(context);
 }
 
-OpFoldResult AffineLoadOp::fold(ArrayRef<Attribute> cstOperands) {
+ValueOrAttr AffineLoadOp::fold(ArrayRef<Attribute> cstOperands) {
   /// load(memrefcast) -> load
   if (succeeded(foldMemRefCast(*this)))
     return getResult();
-  return OpFoldResult();
+  return ValueOrAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // AffineStoreOp
 //===----------------------------------------------------------------------===//
 
 void AffineStoreOp::build(OpBuilder &builder, OperationState &result,
                           Value valueToStore, Value memref, AffineMap map,

 }
 
 void AffineStoreOp::getCanonicalizationPatterns(
     OwningRewritePatternList &results, MLIRContext *context) {
   results.insert<SimplifyAffineOp<AffineStoreOp>>(context);
 }
 
 LogicalResult AffineStoreOp::fold(ArrayRef<Attribute> cstOperands,
-                                  SmallVectorImpl<OpFoldResult> &results) {
+                                  SmallVectorImpl<ValueOrAttr> &results) {
   /// store(memrefcast) -> store
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // AffineMinMaxOpBase
 //===----------------------------------------------------------------------===//
 
return failure(
       parser.resolveOperands(sym_infos, indexType, result.operands) ||
       parser.addTypeToList(indexType, result.types));
 }
 
 /// Fold an affine min or max operation with the given operands. The operand
 /// list may contain nulls, which are interpreted as the operand not being a
 /// constant.
 template <typename T>
-static OpFoldResult foldMinMaxOp(T op, ArrayRef<Attribute> operands) {
+static ValueOrAttr foldMinMaxOp(T op, ArrayRef<Attribute> operands) {
   static_assert(llvm::is_one_of<T, AffineMinOp, AffineMaxOp>::value,
                 "expected affine min or max op");
 
   // Fold the affine map.
   // TODO: Fold more cases:
   // min(some_affine, some_affine + constant, ...), etc.
   SmallVector<int64_t, 2> results;
   auto foldedMap = op.map().partialConstantFold(operands, &results);

 
 //===----------------------------------------------------------------------===//
 // AffineMinOp
 //===----------------------------------------------------------------------===//
 //
 //   %0 = affine.min (d0) -> (1000, d0 + 512) (%i0)
 //
 
-OpFoldResult AffineMinOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr AffineMinOp::fold(ArrayRef<Attribute> operands) {
   return foldMinMaxOp(*this, operands);
 }
 
 void AffineMinOp::getCanonicalizationPatterns(
     OwningRewritePatternList &patterns, MLIRContext *context) {
   patterns.insert<SimplifyAffineOp<AffineMinOp>>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // AffineMaxOp
 //===----------------------------------------------------------------------===//
 //
 //   %0 = affine.max (d0) -> (1000, d0 + 512) (%i0)
 //
 
-OpFoldResult AffineMaxOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr AffineMaxOp::fold(ArrayRef<Attribute> operands) {
   return foldMinMaxOp(*this, operands);
 }
 
 void AffineMaxOp::getCanonicalizationPatterns(
     OwningRewritePatternList &patterns, MLIRContext *context) {
   patterns.insert<SimplifyAffineOp<AffineMaxOp>>(context);
 }
 

 
 void AffinePrefetchOp::getCanonicalizationPatterns(
     OwningRewritePatternList &results, MLIRContext *context) {
   // prefetch(memrefcast) -> prefetch
   results.insert<SimplifyAffineOp<AffinePrefetchOp>>(context);
 }
 
 LogicalResult AffinePrefetchOp::fold(ArrayRef<Attribute> cstOperands,
-                                     SmallVectorImpl<OpFoldResult> &results) {
+                                     SmallVectorImpl<ValueOrAttr> &results) {
   /// prefetch(memrefcast) -> prefetch
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // AffineParallelOp
 //===----------------------------------------------------------------------===//
 
if (lbCanonicalized)
     op.setLowerBounds(lb.getOperands(), lb.getAffineMap());
   if (ubCanonicalized)
     op.setUpperBounds(ub.getOperands(), ub.getAffineMap());
 
   return success();
 }
 
 LogicalResult AffineParallelOp::fold(ArrayRef<Attribute> operands,
-                                     SmallVectorImpl<OpFoldResult> &results) {
+                                     SmallVectorImpl<ValueOrAttr> &results) {
   return canonicalizeLoopBounds(*this);
 }
 
 static void print(OpAsmPrinter &p, AffineParallelOp op) {
   p << op.getOperationName() << " (" << op.getBody()->getArguments() << ") = (";
   p.printAffineMapOfSSAIds(op.lowerBoundsMapAttr(),
                            op.getLowerBoundsOperands());
   p << ") to (";

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

parseNamedStructuredOp(OpAsmParser &parser, OperationState &result,
                        ArrayRef<OpAsmParser::OperandType> captures = {});
 
 static void printNamedStructuredOpResults(OpAsmPrinter &p,
                                           TypeRange resultTypes);
 
 template <typename NamedStructuredOpType>
 static void printNamedStructuredOp(OpAsmPrinter &p, NamedStructuredOpType op);
 
-/// Helper function to dispatch an OpFoldResult into either the `dynamicVec` if
+/// Helper function to dispatch an ValueOrAttr into either the `dynamicVec` if
 /// it is a Value or into `staticVec` if it is an IntegerAttr.
 /// In the case of a Value, a copy of the `sentinel` value is also pushed to
 /// `staticVec`. This is useful to extract mixed static and dynamic entries that
 /// come from an AttrSizedOperandSegments trait.
-static void dispatchIndexOpFoldResult(OpFoldResult ofr,
-                                      SmallVectorImpl<Value> &dynamicVec,
-                                      SmallVectorImpl<int64_t> &staticVec,
-                                      int64_t sentinel) {
+static void dispatchIndexValueOrAttr(ValueOrAttr ofr,
   if (auto v = ofr.dyn_cast<Value>()) {
     dynamicVec.push_back(v);
     staticVec.push_back(sentinel);
     return;
   }
   APInt apInt = ofr.dyn_cast<Attribute>().cast<IntegerAttr>().getValue();
   staticVec.push_back(apInt.getSExtValue());
 }

 static LogicalResult verify(GenericOp op) { return verifyGenericOp(op); }
 
 static LogicalResult verify(IndexedGenericOp op) { return verifyGenericOp(op); }
 
 //===----------------------------------------------------------------------===//
 // InitTensorOp
 //===----------------------------------------------------------------------===//
 void InitTensorOp::build(OpBuilder &b, OperationState &result,
-                         ArrayRef<OpFoldResult> sizes, Type elementType,
+                         ArrayRef<ValueOrAttr> sizes, Type elementType,
                          ArrayRef<NamedAttribute> attrs) {
   unsigned rank = sizes.size();
   SmallVector<Value, 4> dynamicSizes;
   SmallVector<int64_t, 4> staticSizes;
   for (unsigned i = 0; i < rank; ++i) {
     // staticLow and staticHigh have full information of the padding config.
     // This will grow staticLow and staticHigh with 1 value. If the config is
     // dynamic (ie not a constant), dynamicLow and dynamicHigh will grow with 1
     // value as well.
-    dispatchIndexOpFoldResult(sizes[i], dynamicSizes, staticSizes,
-                              ShapedType::kDynamicSize);
+    dispatchIndexValueOrAttr(sizes[i], dynamicSizes, staticSizes,
   }
   auto resultType = RankedTensorType ::get(staticSizes, elementType);
   build(b, result, resultType, dynamicSizes, b.getI64ArrayAttr(staticSizes));
   result.addAttributes(attrs);
 }
 
 static LogicalResult verify(InitTensorOp op) {
   RankedTensorType resultType = op.getType();
void PadTensorOp::build(OpBuilder &b, OperationState &result, Value source,
                         ArrayRef<NamedAttribute> attrs) {
   auto sourceType = source.getType().cast<RankedTensorType>();
   unsigned rank = sourceType.getRank();
   SmallVector<int64_t, 4> staticVector(ShapedType::kDynamicSize, rank);
   build(b, result, source, staticVector, staticVector, low, high, attrs);
 }
 
 void PadTensorOp::build(OpBuilder &b, OperationState &result, Type resultType,
-                        Value source, ArrayRef<OpFoldResult> low,
-                        ArrayRef<OpFoldResult> high,
+                        Value source, ArrayRef<ValueOrAttr> low,
+                        ArrayRef<ValueOrAttr> high,
                         ArrayRef<NamedAttribute> attrs) {
   assert(resultType.isa<RankedTensorType>());
   auto sourceType = source.getType().cast<RankedTensorType>();
   unsigned rank = sourceType.getRank();
   SmallVector<Value, 4> dynamicLow, dynamicHigh;
   SmallVector<int64_t, 4> staticLow, staticHigh;
   for (unsigned i = 0; i < rank; ++i) {
     // staticLow and staticHigh have full information of the padding config.
     // This will grow staticLow and staticHigh with 1 value. If the config is
     // dynamic (ie not a constant), dynamicLow and dynamicHigh will grow with 1
     // value as well.
-    dispatchIndexOpFoldResult(low[i], dynamicLow, staticLow,
-                              ShapedType::kDynamicSize);
-    dispatchIndexOpFoldResult(high[i], dynamicHigh, staticHigh,
-                              ShapedType::kDynamicSize);
+    dispatchIndexValueOrAttr(low[i], dynamicLow, staticLow,
+    dispatchIndexValueOrAttr(high[i], dynamicHigh, staticHigh,
   }
   if (!resultType) {
     resultType =
         PadTensorOp::inferResultType(sourceType, staticLow, staticHigh);
   }
   build(b, result, resultType, source, dynamicLow, dynamicHigh,
         b.getI64ArrayAttr(staticLow), b.getI64ArrayAttr(staticHigh));
 }
 
 PadTensorOp PadTensorOp::createPadScalarOp(Type type, Value source, Value pad,
-                                           ArrayRef<OpFoldResult> low,
-                                           ArrayRef<OpFoldResult> high,
+                                           ArrayRef<ValueOrAttr> low,
+                                           ArrayRef<ValueOrAttr> high,
                                            Location loc, OpBuilder &builder) {
   auto padTensorOp =
       builder.create<linalg::PadTensorOp>(loc, type, source, low, high);
   int rank = padTensorOp.getResultType().getRank();
   SmallVector<Type, 4> blockArgTypes;
   blockArgTypes.assign(rank, builder.getIndexType());
   auto &region = padTensorOp.region();
   // `builder.createBlock` changes the insertion point within the block. Create
   // a guard to reset the insertion point of the builder after it is destroyed.
   OpBuilder::InsertionGuard guard(builder);
   builder.createBlock(&region, region.end(), blockArgTypes);
   builder.create<linalg::YieldOp>(loc, pad);
   return padTensorOp;
 }
 
 PadTensorOp PadTensorOp::createPadHighOp(Type type, Value source, Value pad,
                                          Location loc, OpBuilder &builder) {
-  SmallVector<OpFoldResult, 4> low, high;
+  SmallVector<ValueOrAttr, 4> low, high;
   auto rankedTensorType = type.cast<RankedTensorType>();
   assert(rankedTensorType.hasStaticShape());
   int rank = rankedTensorType.getRank();
   for (int i = 0; i < rank; ++i) {
     auto dimOp = builder.createOrFold<DimOp>(loc, source, i);
     auto resultDimSize = builder.createOrFold<ConstantIndexOp>(
         loc, rankedTensorType.getDimSize(i));
     auto highValue = builder.createOrFold<SubIOp>(loc, resultDimSize, dimOp);
if (areReshapeOpsFoldable(srcReshapeOp.getSrcType(), reshapeOp.getSrcType(),
       return success();
     }
     return failure();
   }
 };
 } // namespace
 
 template <typename ReshapeOpTy>
-static OpFoldResult foldReshapeOp(ReshapeOpTy reshapeOp,
-                                  ArrayRef<Attribute> operands) {
+static ValueOrAttr foldReshapeOp(ReshapeOpTy reshapeOp,
   // Fold producer-consumer reshape ops that where the operand type of the
   // producer is same as the return type of the consumer.
   ReshapeOpTy reshapeSrcOp =
       reshapeOp.src().template getDefiningOp<ReshapeOpTy>();
   if (reshapeSrcOp && reshapeSrcOp.getSrcType() == reshapeOp.getResultType())
     return reshapeSrcOp.src();
   // Reshape of a constant can be replaced with a new constant.
   if (auto elements = operands.front().dyn_cast_or_null<DenseElementsAttr>()) {
llvm::interleave(
       types.begin(), types.end(), [&](Type t) { appendMangledType(ss, t); },
       [&]() { ss << "_"; });
   return ss.str();
 }
 
 // TODO: Consider making all this boilerplate easy to autogenerate
 // with Tablegen. This seems a desirable property in the context of
 // OpInterfaces where a Linalg "named" op **isa** LinalgOp.
-OpFoldResult ReshapeOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr ReshapeOp::fold(ArrayRef<Attribute> operands) {
   if (succeeded(foldMemRefCast(*this)))
     return getResult();
   return foldReshapeOp(*this, operands);
 }
-OpFoldResult TensorReshapeOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr TensorReshapeOp::fold(ArrayRef<Attribute> operands) {
   return foldReshapeOp(*this, operands);
 }
 
 //===----------------------------------------------------------------------===//
 // Support for named Linalg ops defined in ods-gen.
 //===----------------------------------------------------------------------===//
 
 /// Generic entry point to create the block for the region of a LinalgOp.
#define CANONICALIZERS_AND_FOLDERS(XXX)                                        \
   void XXX::getCanonicalizationPatterns(OwningRewritePatternList &results,     \
                                         MLIRContext *context) {                \
     results.insert<DeduplicateInputs, EraseDeadLinalgOp, FoldTensorCastOp,     \
                    RemoveIdentityLinalgOps>();                                 \
     results.insert<ReplaceDimOfLinalgOpResult>(context);                       \
   }                                                                            \
                                                                                \
   LogicalResult XXX::fold(ArrayRef<Attribute>,                                 \
-                          SmallVectorImpl<OpFoldResult> &) {                   \
+                          SmallVectorImpl<ValueOrAttr> &) {                    \
     return foldMemRefCast(*this);                                              \
   }
 
 CANONICALIZERS_AND_FOLDERS(ConvOp)
 CANONICALIZERS_AND_FOLDERS(PoolingMaxOp)
 CANONICALIZERS_AND_FOLDERS(PoolingMinOp)
 CANONICALIZERS_AND_FOLDERS(PoolingSumOp)
 CANONICALIZERS_AND_FOLDERS(CopyOp)
 CANONICALIZERS_AND_FOLDERS(FillOp)
 CANONICALIZERS_AND_FOLDERS(GenericOp)
 CANONICALIZERS_AND_FOLDERS(IndexedGenericOp)
 
 // All named ops canonicalizers and folders are auto-generated in the
 // .cpp.inc.

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

 ///
 /// More advanced use cases, analyses as well as profitability heuristics are
 /// left for future work.
 
 // Fill `offset`, `sizes` and `strides` used to iterate over the shape indexed
 // by `permutationMap`.
 static void inferShapeComponents(AffineMap permutationMap,
                                  ArrayRef<Range> loopRanges,
-                                 SmallVectorImpl<OpFoldResult> &offsets,
-                                 SmallVectorImpl<OpFoldResult> &sizes,
-                                 SmallVectorImpl<OpFoldResult> &strides) {
+                                 SmallVectorImpl<ValueOrAttr> &offsets,
+                                 SmallVectorImpl<ValueOrAttr> &sizes,
+                                 SmallVectorImpl<ValueOrAttr> &strides) {
   assert(permutationMap.isProjectedPermutation() &&
          "expected some subset of a permutation map");
   SmallVector<Range, 4> shapeRanges(permutationMap.getNumResults());
   unsigned idx = 0;
   for (AffineExpr e : permutationMap.getResults()) {
     // loopToOperandRangesMaps are permutations-only, just swap indices.
     unsigned loopPos = e.cast<AffineDimExpr>().getPosition();
     shapeRanges[idx++] = loopRanges[loopPos];
static LinalgOp cloneWithLoopRanges(OpBuilder &b, Location loc, LinalgOp op,
 
   // Iterate over the shape operands in order.
   // Extract the subranges from the linearized ranges.
   for (auto en : llvm::enumerate(op.getShapedOperands())) {
     unsigned shapedOperandIdx = en.index();
     AffineMap map = op.getIndexingMap(shapedOperandIdx);
     LLVM_DEBUG(llvm::dbgs() << "shapedOperandIdx: " << shapedOperandIdx
                             << " with indexingMap: " << map << "\n");
-    SmallVector<OpFoldResult, 4> offsets, sizes, strides;
+    SmallVector<ValueOrAttr, 4> offsets, sizes, strides;
     inferShapeComponents(map, loopRanges, offsets, sizes, strides);
     Value shape = en.value();
     Value sub = shape.getType().isa<MemRefType>()
                     ? b.create<SubViewOp>(loc, shape, offsets, sizes, strides)
                           .getResult()
                     : b.create<SubTensorOp>(loc, shape, offsets, sizes, strides)
                           .getResult();
     clonedShapes.push_back(sub);

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

 /// instructions that need to be hoisted too.
 struct HoistableRead {
   vector::TransferReadOp transferReadOp;
   SubTensorOp subTensorOp;
 };
 } // namespace
 
 /// Return true if op1 and op2 are the same constant or the same SSA value.
-static bool isEqualOffsetSizeOrStride(OpFoldResult op1, OpFoldResult op2) {
-  auto getConstantIntValue = [](OpFoldResult ofr) -> llvm::Optional<int64_t> {
+static bool isEqualOffsetSizeOrStride(ValueOrAttr op1, ValueOrAttr op2) {
+  auto getConstantIntValue = [](ValueOrAttr ofr) -> llvm::Optional<int64_t> {
     Attribute attr = ofr.dyn_cast<Attribute>();
     // Note: isa+cast-like pattern allows writing the condition below as 1 line.
     if (!attr && ofr.get<Value>().getDefiningOp<ConstantOp>())
       attr = ofr.get<Value>().getDefiningOp<ConstantOp>().getValue();
     if (auto intAttr = attr.dyn_cast_or_null<IntegerAttr>())
       return intAttr.getValue().getSExtValue();
     return llvm::None;
   };
for (Operation *op : backwardSlice) {
     leadingPackedTensorIndexings.push_back(
         buildLoopIterationCount(b, clonedForOp));
     bvm.map(forOp.getInductionVar(), clonedLoopIvs.back());
     packedTensor = clonedForOp.getRegionIterArgs().front();
   }
 
   // Stack step 2. create SubTensorInsertOp at the top of the stack.
   // offsets = [clonedLoopIvs, 0 .. 0].
-  SmallVector<OpFoldResult> offsets(leadingPackedTensorIndexings.begin(),
-                                    leadingPackedTensorIndexings.end());
+  SmallVector<ValueOrAttr> offsets(leadingPackedTensorIndexings.begin(),
   offsets.append(paddedRank, b.getIndexAttr(0));
   // sizes = [1 .. 1, paddedShape].
-  SmallVector<OpFoldResult> sizes(nLoops, b.getIndexAttr(1));
+  SmallVector<ValueOrAttr> sizes(nLoops, b.getIndexAttr(1));
   for (int64_t sz : paddedTensorType.getShape()) {
     // TODO: go grab dims when necessary, for now PadTensorOp returns a static
     // tensor.
     assert(!ShapedType::isDynamic(sz) && "padded tensor needs static sizes");
     sizes.push_back(b.getIndexAttr(sz));
   }
   // strides = [1 .. 1].
-  SmallVector<OpFoldResult> strides(nLoops + paddedRank, b.getIndexAttr(1));
+  SmallVector<ValueOrAttr> strides(nLoops + paddedRank, b.getIndexAttr(1));
 
   Value inserted =
       b.create<SubTensorInsertOp>(loc, bvm.lookup(padTensorOp.result()),
                                   packedTensor, offsets, sizes, strides);
 
   // Stack step 3. iteratively pop the stack and propagate the yield.
   Value valueToYield = inserted;
   for (Value iv : llvm::reverse(clonedLoopIvs)) {

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

 // by a partial `copy` op.
 Optional<PromotionInfo> mlir::linalg::promoteSubviewAsNewBuffer(
     OpBuilder &b, Location loc, SubViewOp subView,
     AllocBufferCallbackFn allocationFn, OperationFolder *folder) {
   ScopedContext scopedContext(b, loc);
   auto viewType = subView.getType();
   auto rank = viewType.getRank();
   SmallVector<Value, 4> fullSizes;
-  SmallVector<OpFoldResult> partialSizes;
+  SmallVector<ValueOrAttr> partialSizes;
   fullSizes.reserve(rank);
   partialSizes.reserve(rank);
   for (auto en : llvm::enumerate(subView.getOrCreateRanges(b, loc))) {
     auto rangeValue = en.value();
     // Try to extract a tight constant.
     LLVM_DEBUG(llvm::dbgs() << "Extract tightest: " << rangeValue.size << "\n");
     IntegerAttr sizeAttr = getSmallestBoundingIndex(rangeValue.size);
     Value size =
         (!sizeAttr) ? rangeValue.size : b.create<ConstantOp>(loc, sizeAttr);
     LLVM_DEBUG(llvm::dbgs() << "Extracted tightest: " << size << "\n");
     fullSizes.push_back(size);
     partialSizes.push_back(folded_std_dim(folder, subView, en.index()).value);
   }
   SmallVector<int64_t, 4> dynSizes(fullSizes.size(), -1);
   // If a callback is not specified, then use the default implementation for
   // allocating the promoted buffer.
   Optional<Value> fullLocalView = allocationFn(b, subView, fullSizes, folder);
   if (!fullLocalView)
     return {};
-  SmallVector<OpFoldResult, 4> zeros(fullSizes.size(), b.getIndexAttr(0));
-  SmallVector<OpFoldResult, 4> ones(fullSizes.size(), b.getIndexAttr(1));
+  SmallVector<ValueOrAttr, 4> zeros(fullSizes.size(), b.getIndexAttr(0));
+  SmallVector<ValueOrAttr, 4> ones(fullSizes.size(), b.getIndexAttr(1));
   auto partialLocalView =
       folded_std_subview(folder, *fullLocalView, zeros, partialSizes, ones);
   return PromotionInfo{*fullLocalView, partialLocalView};
 }
 
 static Optional<MapVector<unsigned, PromotionInfo>>
 promoteSubViews(OpBuilder &b, Location loc,
                 LinalgOpInstancePromotionOptions options,

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

for (auto en : llvm::enumerate(tiledOperands)) {
     AffineMap map = linalgOp.getIndexingMap(en.index());
     // If the shape is not tiled, we can use it as is.
     if (!isTiled(map, tileSizes)) {
       res.push_back(shapedOp);
       continue;
     }
 
     // Construct a new subview / subtensor for the tile.
-    SmallVector<OpFoldResult, 4> offsets, sizes, strides;
+    SmallVector<ValueOrAttr, 4> offsets, sizes, strides;
     offsets.reserve(rank);
     sizes.reserve(rank);
     strides.reserve(rank);
     for (unsigned r = 0; r < rank; ++r) {
       if (!isTiled(map.getSubMap({r}), tileSizes)) {
         offsets.push_back(b.getIndexAttr(0));
         sizes.push_back(std_dim(shapedOp, r).value);
         strides.push_back(b.getIndexAttr(1));

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

static LogicalResult rewriteAsPaddedOp(PatternRewriter &rewriter,
   // Recover the subtensor out of the new static results. This keeps the
   // original linalg op around because it uses the dims of the original results.
   // This later folds away.
   SmallVector<Value> paddedSubviewResults;
   paddedSubviewResults.reserve(opToPad->getNumResults());
   llvm::SetVector<Operation *> newUsersOfOpToPad;
   for (auto it : llvm::zip(opToPad->getResults(), paddedOp->getResults())) {
     auto rank = std::get<0>(it).getType().cast<RankedTensorType>().getRank();
-    SmallVector<OpFoldResult> offsets(rank, rewriter.getIndexAttr(0));
+    SmallVector<ValueOrAttr> offsets(rank, rewriter.getIndexAttr(0));
     auto sizes = llvm::to_vector<4>(llvm::map_range(
-        llvm::seq<unsigned>(0, rank), [&](unsigned d) -> OpFoldResult {
+        llvm::seq<unsigned>(0, rank), [&](unsigned d) -> ValueOrAttr {
           auto dimOp = rewriter.create<DimOp>(loc, std::get<0>(it), d);
           newUsersOfOpToPad.insert(dimOp);
           return dimOp.getResult();
         }));
-    SmallVector<OpFoldResult> strides(rank, rewriter.getIndexAttr(1));
+    SmallVector<ValueOrAttr> strides(rank, rewriter.getIndexAttr(1));
     paddedSubviewResults.push_back(rewriter.create<SubTensorOp>(
         loc, std::get<1>(it), offsets, sizes, strides));
   }
   // Replace the transient `opToPad` locally, except for uses that we just
   // created for the purpose of extracting the dims.
   rewriter.replaceOpWithIf(opToPad, paddedSubviewResults, [&](OpOperand &opOp) {
     return !newUsersOfOpToPad.contains(opOp.getOwner());
   });

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

 // Misc. vectorization patterns.
 //----------------------------------------------------------------------------//
 
 /// Rewrite a PadTensorOp into a sequence of InitTensorOp, TransferReadOp and
 /// TransferWriteOp. For now, this only applies when all low and high paddings
 /// are determined to be zero.
 LogicalResult PadTensorOpVectorizationPattern::matchAndRewrite(
     linalg::PadTensorOp padOp, PatternRewriter &rewriter) const {
-  // Helper function to determine whether an OpFoldResult is not a zero Index.
-  auto isNotZeroIndex = [](OpFoldResult ofr) {
+  // Helper function to determine whether an ValueOrAttr is not a zero Index.
+  auto isNotZeroIndex = [](ValueOrAttr ofr) {
     if (Attribute attr = ofr.dyn_cast<Attribute>())
       return attr.cast<IntegerAttr>().getInt() != 0;
     Value v = ofr.get<Value>();
     if (auto constOp = v.getDefiningOp<ConstantOp>())
       if (auto intAttr = constOp.getValue().dyn_cast<IntegerAttr>())
         return intAttr.getValue().getSExtValue() != 0;
     return true;
   };
LogicalResult PadTensorOpVectorizationPattern::matchAndRewrite(
   Operation *definingOp = padValue.getDefiningOp();
   if (definingOp && definingOp->getBlock() == &block)
     return failure();
   if (!definingOp && padValue.cast<BlockArgument>().getOwner() == &block)
     return failure();
 
   // TODO: if any pad_high is not a static 0, needs a mask. For now, just bail.
   if (llvm::any_of(padOp.getMixedHighPad(),
-                   [&](OpFoldResult ofr) { return isNotZeroIndex(ofr); }))
+                   [&](ValueOrAttr ofr) { return isNotZeroIndex(ofr); }))
     return failure();
 
   // Now we can rewrite as InitTensorOp + TransferReadOp@[0..0] +
   // TransferWriteOp@[0..0].
   SmallVector<Value> indices(
       resultShapedType.getRank(),
       rewriter.create<ConstantIndexOp>(padOp.getLoc(), 0));
   Value read = rewriter.create<vector::TransferReadOp>(

mlir/lib/Dialect/Quant/IR/QuantOps.cpp

void QuantizationDialect::initialize() {
   addTypes<AnyQuantizedType, CalibratedQuantizedType, UniformQuantizedType,
            UniformQuantizedPerAxisType>();
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Quant/QuantOps.cpp.inc"
       >();
 }
 
-OpFoldResult StorageCastOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr StorageCastOp::fold(ArrayRef<Attribute> operands) {
   // Matches x -> [scast -> scast] -> y, replacing the second scast with the
   // value of x if the casts invert each other.
   auto srcScastOp = arg().getDefiningOp<StorageCastOp>();
   if (!srcScastOp || srcScastOp.arg().getType() != getType())
-    return OpFoldResult();
+    return ValueOrAttr();
   return srcScastOp.arg();
 }
 
 /// The quantization specification should match the expressed type.
 static bool isValidQuantizationSpec(Attribute quantSpec, Type expressed) {
   if (auto typeAttr = quantSpec.dyn_cast<TypeAttr>()) {
     Type spec = typeAttr.getValue();
     if (spec.isa<TensorType, VectorType>())

mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp

void spirv::BitcastOp::getCanonicalizationPatterns(
     OwningRewritePatternList &results, MLIRContext *context) {
   results.insert<ConvertChainedBitcast>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.CompositeExtractOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult spirv::CompositeExtractOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr spirv::CompositeExtractOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 1 && "spv.CompositeExtract expects one operand");
   auto indexVector =
       llvm::to_vector<8>(llvm::map_range(indices(), [](Attribute attr) {
         return static_cast<unsigned>(attr.cast<IntegerAttr>().getInt());
       }));
   return extractCompositeElement(operands[0], indexVector);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.constant
 //===----------------------------------------------------------------------===//
 
-OpFoldResult spirv::ConstantOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr spirv::ConstantOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.empty() && "spv.constant has no operands");
   return value();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.IAdd
 //===----------------------------------------------------------------------===//
 
-OpFoldResult spirv::IAddOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr spirv::IAddOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "spv.IAdd expects two operands");
   // x + 0 = x
   if (matchPattern(operand2(), m_Zero()))
     return operand1();
 
   // According to the SPIR-V spec:
   //
   // The resulting value will equal the low-order N bits of the correct result
   // R, where N is the component width and R is computed with enough precision
   // to avoid overflow and underflow.
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a + b; });
 }
 
 //===----------------------------------------------------------------------===//
 // spv.IMul
 //===----------------------------------------------------------------------===//
 
-OpFoldResult spirv::IMulOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr spirv::IMulOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "spv.IMul expects two operands");
   // x * 0 == 0
   if (matchPattern(operand2(), m_Zero()))
     return operand2();
   // x * 1 = x
   if (matchPattern(operand2(), m_One()))
     return operand1();
 
   // According to the SPIR-V spec:
   //
   // The resulting value will equal the low-order N bits of the correct result
   // R, where N is the component width and R is computed with enough precision
   // to avoid overflow and underflow.
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a * b; });
 }
 
 //===----------------------------------------------------------------------===//
 // spv.ISub
 //===----------------------------------------------------------------------===//
 
-OpFoldResult spirv::ISubOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr spirv::ISubOp::fold(ArrayRef<Attribute> operands) {
   // x - x = 0
   if (operand1() == operand2())
     return Builder(getContext()).getIntegerAttr(getType(), 0);
 
   // According to the SPIR-V spec:
   //
   // The resulting value will equal the low-order N bits of the correct result
   // R, where N is the component width and R is computed with enough precision
   // to avoid overflow and underflow.
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a - b; });
 }
 
 //===----------------------------------------------------------------------===//
 // spv.LogicalAnd
 //===----------------------------------------------------------------------===//
 
-OpFoldResult spirv::LogicalAndOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr spirv::LogicalAndOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "spv.LogicalAnd should take two operands");
 
   if (Optional<bool> rhs = getScalarOrSplatBoolAttr(operands.back())) {
     // x && true = x
     if (rhs.getValue())
       return operand1();
 
     // x && false = false
results.insert<ConvertLogicalNotOfIEqual, ConvertLogicalNotOfINotEqual,
                  ConvertLogicalNotOfLogicalEqual,
                  ConvertLogicalNotOfLogicalNotEqual>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.LogicalOr
 //===----------------------------------------------------------------------===//
 
-OpFoldResult spirv::LogicalOrOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr spirv::LogicalOrOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "spv.LogicalOr should take two operands");
 
   if (auto rhs = getScalarOrSplatBoolAttr(operands.back())) {
     if (rhs.getValue())
       // x || true = true
       return operands.back();
 
     // x || false = x

mlir/lib/Dialect/Shape/IR/Shape.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // AnyOp
 //===----------------------------------------------------------------------===//
 
 // TODO: Canonicalization should be implemented for shapes that can be
 // determined through mixtures of the known dimensions of the inputs.
-OpFoldResult AnyOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr AnyOp::fold(ArrayRef<Attribute> operands) {
   // Only the last operand is checked because AnyOp is commutative.
   if (operands.back())
     return operands.back();
 
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//

 // AssumingAllOp
 //===----------------------------------------------------------------------===//
 
 void AssumingAllOp::getCanonicalizationPatterns(
     OwningRewritePatternList &patterns, MLIRContext *context) {
   patterns.insert<AssumingAllOneOp>(context);
 }
 
-OpFoldResult AssumingAllOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr AssumingAllOp::fold(ArrayRef<Attribute> operands) {
   // Iterate in reverse to first handle all constant operands. They are
   // guaranteed to be the tail of the inputs because this is commutative.
   for (int idx = operands.size() - 1; idx >= 0; idx--) {
     Attribute a = operands[idx];
     // Cannot fold if any inputs are not constant;
     if (!a)
       return nullptr;
 
static LogicalResult verify(AssumingAllOp op) {
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // BroadcastOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult BroadcastOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr BroadcastOp::fold(ArrayRef<Attribute> operands) {
   if (!operands[1])
     return nullptr;
 
   // TODO: Support folding with more than 2 input shapes
   if (operands.size() > 2 && !operands[2].isa<StringAttr>())
     return nullptr;
 
   auto rhsShape = llvm::to_vector<6>(
static LogicalResult verify(BroadcastOp op) {
 
   return verifyShapeOrExtentTensorOp(op);
 }
 
 //===----------------------------------------------------------------------===//
 // ConcatOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult ConcatOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr ConcatOp::fold(ArrayRef<Attribute> operands) {
   if (!operands[0] || !operands[1])
     return nullptr;
   auto lhsShape = llvm::to_vector<6>(
       operands[0].cast<DenseIntElementsAttr>().getValues<int64_t>());
   auto rhsShape = llvm::to_vector<6>(
       operands[1].cast<DenseIntElementsAttr>().getValues<int64_t>());
   SmallVector<int64_t, 6> resultShape;
   resultShape.append(lhsShape.begin(), lhsShape.end());
static ParseResult parseConstShapeOp(OpAsmParser &parser,
   result.addAttribute("shape", builder.getIndexTensorAttr(ints));
   Type resultTy;
   if (parser.parseColonType(resultTy))
     return failure();
   result.types.push_back(resultTy);
   return success();
 }
 
-OpFoldResult ConstShapeOp::fold(ArrayRef<Attribute>) { return shapeAttr(); }
+ValueOrAttr ConstShapeOp::fold(ArrayRef<Attribute>) { return shapeAttr(); }
 
 void ConstShapeOp::getCanonicalizationPatterns(
     OwningRewritePatternList &patterns, MLIRContext *context) {
   patterns.insert<TensorCastConstShape>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // CstrBroadcastableOp

 void CstrBroadcastableOp::getCanonicalizationPatterns(
     OwningRewritePatternList &patterns, MLIRContext *context) {
   // Canonicalization patterns have overlap with the considerations during
   // folding in case additional shape information is inferred at some point that
   // does not result in folding.
   patterns.insert<CstrBroadcastableEqOps>(context);
 }
 
-OpFoldResult CstrBroadcastableOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr CstrBroadcastableOp::fold(ArrayRef<Attribute> operands) {
   // TODO: Add folding for the nary case
   if (operands.size() != 2)
     return nullptr;
 
   // Both operands are not needed if one is a scalar.
   if (operands[0] &&
       operands[0].cast<DenseIntElementsAttr>().getNumElements() == 0)
     return BoolAttr::get(getContext(), true);

 //===----------------------------------------------------------------------===//
 
 void CstrEqOp::getCanonicalizationPatterns(OwningRewritePatternList &patterns,
                                            MLIRContext *context) {
   // If inputs are equal, return passing witness
   patterns.insert<CstrEqEqOps>(context);
 }
 
-OpFoldResult CstrEqOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr CstrEqOp::fold(ArrayRef<Attribute> operands) {
   if (llvm::all_of(operands,
                    [&](Attribute a) { return a && a == operands[0]; }))
     return BoolAttr::get(getContext(), true);
 
   // Because a failing witness result here represents an eventual assertion
   // failure, we do not try to replace it with a constant witness. Similarly, we
   // cannot if there are any non-const inputs.
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // ConstSizeOp
 //===----------------------------------------------------------------------===//
 
 void ConstSizeOp::build(OpBuilder &builder, OperationState &result,
                         int64_t value) {
   build(builder, result, builder.getIndexAttr(value));
 }
 
-OpFoldResult ConstSizeOp::fold(ArrayRef<Attribute>) { return valueAttr(); }
+ValueOrAttr ConstSizeOp::fold(ArrayRef<Attribute>) { return valueAttr(); }
 
 void ConstSizeOp::getAsmResultNames(
     llvm::function_ref<void(Value, StringRef)> setNameFn) {
   SmallString<4> buffer;
   llvm::raw_svector_ostream os(buffer);
   os << "c" << value();
   setNameFn(getResult(), os.str());
 }
 
 //===----------------------------------------------------------------------===//
 // ConstWitnessOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult ConstWitnessOp::fold(ArrayRef<Attribute>) { return passingAttr(); }
+ValueOrAttr ConstWitnessOp::fold(ArrayRef<Attribute>) { return passingAttr(); }
 
 //===----------------------------------------------------------------------===//
 // CstrRequireOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult CstrRequireOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr CstrRequireOp::fold(ArrayRef<Attribute> operands) {
   return operands[0];
 }
 
 //===----------------------------------------------------------------------===//
 // ShapeEqOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult ShapeEqOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr ShapeEqOp::fold(ArrayRef<Attribute> operands) {
   if (lhs() == rhs())
     return BoolAttr::get(getContext(), true);
   auto lhs = operands[0].dyn_cast_or_null<DenseIntElementsAttr>();
   if (lhs == nullptr)
     return {};
   auto rhs = operands[1].dyn_cast_or_null<DenseIntElementsAttr>();
   if (rhs == nullptr)
     return {};
   return BoolAttr::get(getContext(), lhs == rhs);
 }
 
 //===----------------------------------------------------------------------===//
 // IndexToSizeOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult IndexToSizeOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr IndexToSizeOp::fold(ArrayRef<Attribute> operands) {
   // Constant values of both types, `shape.size` and `index`, are represented as
   // `IntegerAttr`s which makes constant folding simple.
   if (Attribute arg = operands[0])
     return arg;
   return {};
 }
 
 void IndexToSizeOp::getCanonicalizationPatterns(
     OwningRewritePatternList &patterns, MLIRContext *context) {
   patterns.insert<SizeToIndexToSizeCanonicalization>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // FromExtentsOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult FromExtentsOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr FromExtentsOp::fold(ArrayRef<Attribute> operands) {
   if (llvm::any_of(operands, [](Attribute a) { return !a; }))
     return nullptr;
   SmallVector<int64_t, 6> extents;
   for (auto attr : operands)
     extents.push_back(attr.cast<IntegerAttr>().getInt());
   Builder builder(getContext());
   return builder.getIndexTensorAttr(extents);
 }

 Optional<int64_t> GetExtentOp::getConstantDim() {
   if (auto constSizeOp = dim().getDefiningOp<ConstSizeOp>())
     return constSizeOp.value().getLimitedValue();
   if (auto constantOp = dim().getDefiningOp<ConstantOp>())
     return constantOp.value().cast<IntegerAttr>().getInt();
   return llvm::None;
 }
 
-OpFoldResult GetExtentOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr GetExtentOp::fold(ArrayRef<Attribute> operands) {
   auto elements = operands[0].dyn_cast_or_null<DenseIntElementsAttr>();
   if (!elements)
     return nullptr;
   Optional<int64_t> dim = getConstantDim();
   if (!dim.hasValue())
     return nullptr;
   if (dim.getValue() >= elements.getNumElements())
     return nullptr;
if (op.getNumOperands() < 2)
     return op.emitOpError("required at least 2 input shapes");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // RankOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult shape::RankOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr shape::RankOp::fold(ArrayRef<Attribute> operands) {
   auto shape = operands[0].dyn_cast_or_null<DenseIntElementsAttr>();
   if (!shape)
     return {};
   int64_t rank = shape.getNumElements();
   Builder builder(getContext());
   return builder.getIndexAttr(rank);
 }
 
void shape::RankOp::getCanonicalizationPatterns(
     OwningRewritePatternList &patterns, MLIRContext *context) {
   patterns.insert<RankShapeOfCanonicalizationPattern>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // NumElementsOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult NumElementsOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr NumElementsOp::fold(ArrayRef<Attribute> operands) {
 
   // Fold only when argument constant.
   Attribute shape = operands[0];
   if (!shape)
     return {};
 
   APInt product(64, 1);
   for (auto value : shape.cast<DenseIntElementsAttr>())
void NumElementsOp::build(OpBuilder &builder, OperationState &result,
   auto type = SizeType::get(builder.getContext());
   return build(builder, result, type, shape);
 }
 
 //===----------------------------------------------------------------------===//
 // MulOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult MulOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr MulOp::fold(ArrayRef<Attribute> operands) {
   auto lhs = operands[0].dyn_cast_or_null<IntegerAttr>();
   if (!lhs)
     return nullptr;
   auto rhs = operands[1].dyn_cast_or_null<IntegerAttr>();
   if (!rhs)
     return nullptr;
   APInt folded = lhs.getValue() * rhs.getValue();
   Type indexTy = IndexType::get(getContext());
   return IntegerAttr::get(indexTy, folded);
 }
 
 //===----------------------------------------------------------------------===//
 // ShapeOfOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult ShapeOfOp::fold(ArrayRef<Attribute>) {
+ValueOrAttr ShapeOfOp::fold(ArrayRef<Attribute>) {
   auto type = getOperand().getType().dyn_cast<ShapedType>();
   if (!type || !type.hasStaticShape())
     return nullptr;
   Builder builder(getContext());
   return builder.getIndexTensorAttr(type.getShape());
 }
 
 void ShapeOfOp::build(OpBuilder &builder, OperationState &result, Value arg) {
void ShapeOfOp::getCanonicalizationPatterns(OwningRewritePatternList &patterns,
                                             MLIRContext *context) {
   patterns.insert<ShapeOfWithTensor>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // SizeToIndexOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult SizeToIndexOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr SizeToIndexOp::fold(ArrayRef<Attribute> operands) {
   // Constant values of both types, `shape.size` and `index`, are represented as
   // `IntegerAttr`s which makes constant folding simple.
   if (Attribute arg = operands[0])
     return arg;
   return impl::foldCastOp(*this);
 }
 
 void SizeToIndexOp::getCanonicalizationPatterns(
static LogicalResult verify(shape::YieldOp op) {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SplitAtOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult SplitAtOp::fold(ArrayRef<Attribute> operands,
-                              SmallVectorImpl<OpFoldResult> &results) {
+                              SmallVectorImpl<ValueOrAttr> &results) {
   if (!operands[0] || !operands[1])
     return failure();
   auto shapeVec = llvm::to_vector<6>(
       operands[0].cast<DenseIntElementsAttr>().getValues<int64_t>());
   auto shape = llvm::makeArrayRef(shapeVec);
   auto splitPoint = operands[1].cast<IntegerAttr>().getInt();
   // Verify that the split point is in the correct range.
   // TODO: Constant fold to an "error".
   int64_t rank = shape.size();
   if (!(-rank <= splitPoint && splitPoint <= rank))
     return failure();
   if (splitPoint < 0)
     splitPoint += shape.size();
   Builder builder(operands[0].getContext());
   results.push_back(builder.getIndexTensorAttr(shape.take_front(splitPoint)));
   results.push_back(builder.getIndexTensorAttr(shape.drop_front(splitPoint)));
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ToExtentTensorOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult ToExtentTensorOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr ToExtentTensorOp::fold(ArrayRef<Attribute> operands) {
   if (!operands[0])
     return impl::foldCastOp(*this);
   Builder builder(getContext());
   auto shape = llvm::to_vector<6>(
       operands[0].cast<DenseIntElementsAttr>().getValues<int64_t>());
   auto type = RankedTensorType::get({static_cast<int64_t>(shape.size())},
                                     builder.getIndexType());
   return DenseIntElementsAttr::get(type, shape);

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
 
 // Pull in all enum type definitions and utility function declarations.
 #include "mlir/Dialect/StandardOps/IR/OpsEnums.cpp.inc"
 
 using namespace mlir;
 
-/// Helper function to dispatch an OpFoldResult into either the `dynamicVec` if
+/// Helper function to dispatch an ValueOrAttr into either the `dynamicVec` if
 /// it is a Value or into `staticVec` if it is an IntegerAttr.
 /// In the case of a Value, a copy of the `sentinel` value is also pushed to
 /// `staticVec`. This is useful to extract mixed static and dynamic entries that
 /// come from an AttrSizedOperandSegments trait.
-static void dispatchIndexOpFoldResult(OpFoldResult ofr,
-                                      SmallVectorImpl<Value> &dynamicVec,
-                                      SmallVectorImpl<int64_t> &staticVec,
-                                      int64_t sentinel) {
+static void dispatchIndexValueOrAttr(ValueOrAttr ofr,
   if (auto v = ofr.dyn_cast<Value>()) {
     dynamicVec.push_back(v);
     staticVec.push_back(sentinel);
     return;
   }
   APInt apInt = ofr.dyn_cast<Attribute>().cast<IntegerAttr>().getValue();
   staticVec.push_back(apInt.getSExtValue());
 }
 
-static void dispatchIndexOpFoldResults(ArrayRef<OpFoldResult> ofrs,
-                                       SmallVectorImpl<Value> &dynamicVec,
-                                       SmallVectorImpl<int64_t> &staticVec,
-                                       int64_t sentinel) {
+static void dispatchIndexValueOrAttrs(ArrayRef<ValueOrAttr> ofrs,
   for (auto ofr : ofrs)
-    dispatchIndexOpFoldResult(ofr, dynamicVec, staticVec, sentinel);
+    dispatchIndexValueOrAttr(ofr, dynamicVec, staticVec, sentinel);
 }
 
 //===----------------------------------------------------------------------===//
 // StandardOpsDialect Interfaces
 //===----------------------------------------------------------------------===//
 namespace {
 /// This class defines the interface for handling inlining with standard
 /// operations.
if (auto memref = type.dyn_cast<UnrankedMemRefType>())
     return UnrankedTensorType::get(memref.getElementType());
   return NoneType::get(type.getContext());
 }
 
 //===----------------------------------------------------------------------===//
 // AddFOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult AddFOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr AddFOp::fold(ArrayRef<Attribute> operands) {
   return constFoldBinaryOp<FloatAttr>(
       operands, [](APFloat a, APFloat b) { return a + b; });
 }
 
 //===----------------------------------------------------------------------===//
 // AddIOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult AddIOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr AddIOp::fold(ArrayRef<Attribute> operands) {
   /// addi(x, 0) -> x
   if (matchPattern(rhs(), m_Zero()))
     return lhs();
 
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a + b; });
 }
 
void AllocaOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                            MLIRContext *context) {
   results.insert<SimplifyAllocConst<AllocaOp>>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // AndOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult AndOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr AndOp::fold(ArrayRef<Attribute> operands) {
   /// and(x, 0) -> 0
   if (matchPattern(rhs(), m_Zero()))
     return rhs();
   /// and(x, allOnes) -> x
   APInt intValue;
   if (matchPattern(rhs(), m_ConstantInt(&intValue)) &&
       intValue.isAllOnesValue())
     return lhs();
static bool applyCmpPredicateToEqualOperands(CmpIPredicate predicate) {
   case CmpIPredicate::ult:
   case CmpIPredicate::ugt:
     return false;
   }
   llvm_unreachable("unknown comparison predicate");
 }
 
 // Constant folding hook for comparisons.
-OpFoldResult CmpIOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr CmpIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "cmpi takes two arguments");
 
   if (lhs() == rhs()) {
     auto val = applyCmpPredicateToEqualOperands(getPredicate());
     return BoolAttr::get(getContext(), val);
   }
 
   auto lhs = operands.front().dyn_cast_or_null<IntegerAttr>();
case CmpFPredicate::UNO:
     return cmpResult == APFloat::cmpUnordered;
   case CmpFPredicate::AlwaysTrue:
     return true;
   }
   llvm_unreachable("unknown comparison predicate");
 }
 
 // Constant folding hook for comparisons.
-OpFoldResult CmpFOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr CmpFOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "cmpf takes two arguments");
 
   auto lhs = operands.front().dyn_cast_or_null<FloatAttr>();
   auto rhs = operands.back().dyn_cast_or_null<FloatAttr>();
 
   // TODO: We could actually do some intelligent things if we know only one
   // of the operands, but it's inf or nan.
   if (!lhs || !rhs)
static LogicalResult verify(ConstantOp &op) {
   }
 
   if (type.isa<NoneType>() && value.isa<UnitAttr>())
     return success();
 
   return op.emitOpError("unsupported 'value' attribute: ") << value;
 }
 
-OpFoldResult ConstantOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr ConstantOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.empty() && "constant has no operands");
   return getValue();
 }
 
 void ConstantOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   Type type = getType();
   if (auto intCst = getValue().dyn_cast<IntegerAttr>()) {

 }
 
 void DeallocOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                             MLIRContext *context) {
   results.insert<SimplifyDeadDealloc>(context);
 }
 
 LogicalResult DeallocOp::fold(ArrayRef<Attribute> cstOperands,
-                              SmallVectorImpl<OpFoldResult> &results) {
+                              SmallVectorImpl<ValueOrAttr> &results) {
   /// dealloc(memrefcast) -> dealloc
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // DimOp
 //===----------------------------------------------------------------------===//
 
if (auto tensorType = type.dyn_cast<RankedTensorType>()) {
     // Assume index to be in range.
   } else {
     llvm_unreachable("expected operand with tensor or memref type");
   }
 
   return success();
 }
 
-OpFoldResult DimOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr DimOp::fold(ArrayRef<Attribute> operands) {
   auto index = operands[1].dyn_cast_or_null<IntegerAttr>();
 
   // All forms of folding require a known index.
   if (!index)
     return {};
 
   auto argTy = memrefOrTensor().getType();
   // Fold if the shape extent along the given index is known.
void DimOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
   results.insert<DimOfMemRefReshape, DimOfCastOp<TensorToMemrefOp>,
                  DimOfCastOp<tensor::CastOp>>(context);
 }
 
 // ---------------------------------------------------------------------------
 // DivFOp
 // ---------------------------------------------------------------------------
 
-OpFoldResult DivFOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr DivFOp::fold(ArrayRef<Attribute> operands) {
   return constFoldBinaryOp<FloatAttr>(
       operands, [](APFloat a, APFloat b) { return a / b; });
 }
 
 // ---------------------------------------------------------------------------
 // DmaStartOp
 // ---------------------------------------------------------------------------
 
if (!getStride().getType().isIndex() ||
       return emitOpError(
           "expected stride and num elements per stride to be of type index");
   }
 
   return success();
 }
 
 LogicalResult DmaStartOp::fold(ArrayRef<Attribute> cstOperands,
-                               SmallVectorImpl<OpFoldResult> &results) {
+                               SmallVectorImpl<ValueOrAttr> &results) {
   /// dma_start(memrefcast) -> dma_start
   return foldMemRefCast(*this);
 }
 
 // ---------------------------------------------------------------------------
 // DmaWaitOp
 // ---------------------------------------------------------------------------
 
if (parser.parseOperand(tagMemrefInfo) ||
       parser.resolveOperands(tagIndexInfos, indexType, result.operands) ||
       parser.resolveOperand(numElementsInfo, indexType, result.operands))
     return failure();
 
   return success();
 }
 
 LogicalResult DmaWaitOp::fold(ArrayRef<Attribute> cstOperands,
-                              SmallVectorImpl<OpFoldResult> &results) {
+                              SmallVectorImpl<ValueOrAttr> &results) {
   /// dma_wait(memrefcast) -> dma_wait
   return foldMemRefCast(*this);
 }
 
 LogicalResult DmaWaitOp::verify() {
   // Mandatory non-variadic operands are tag and the number of elements.
   if (getNumOperands() < 2)
     return emitOpError() << "expected at least 2 operands";
return (aShaped.getShape() == bShaped.getShape()) &&
            areCastCompatible(aShaped.getElementType(),
                              bShaped.getElementType());
   }
 
   return (a.isIndex() && b.isSignlessInteger()) ||
          (a.isSignlessInteger() && b.isIndex());
 }
 
-OpFoldResult IndexCastOp::fold(ArrayRef<Attribute> cstOperands) {
+ValueOrAttr IndexCastOp::fold(ArrayRef<Attribute> cstOperands) {
   // Fold IndexCast(IndexCast(x)) -> x
   auto cast = getOperand().getDefiningOp<IndexCastOp>();
   if (cast && cast.getOperand().getType() == getType())
     return cast.getOperand();
 
   // Fold IndexCast(constant) -> constant
   // A little hack because we go through int.  Otherwise, the size
   // of the constant might need to change.
   if (auto value = cstOperands[0].dyn_cast_or_null<IntegerAttr>())
     return IntegerAttr::get(getType(), value.getInt());
 
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // LoadOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(LoadOp op) {
   if (op.getNumOperands() != 1 + op.getMemRefType().getRank())
     return op.emitOpError("incorrect number of indices for load");
   return success();
 }
 
-OpFoldResult LoadOp::fold(ArrayRef<Attribute> cstOperands) {
+ValueOrAttr LoadOp::fold(ArrayRef<Attribute> cstOperands) {
   /// load(memrefcast) -> load
   if (succeeded(foldMemRefCast(*this)))
     return getResult();
-  return OpFoldResult();
+  return ValueOrAttr();
 }
 
 namespace {
 /// Fold a load on a tensor_to_memref operation into an tensor.extract on the
 /// corresponding tensor.
 struct LoadOfTensorToMemref : public OpRewritePattern<LoadOp> {
   using OpRewritePattern<LoadOp>::OpRewritePattern;
 
if (aMemSpace != bMemSpace)
       return false;
 
     return true;
   }
 
   return false;
 }
 
-OpFoldResult MemRefCastOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr MemRefCastOp::fold(ArrayRef<Attribute> operands) {
   return succeeded(foldMemRefCast(*this)) ? getResult() : Value();
 }
 
 //===----------------------------------------------------------------------===//
 // MemRefReinterpretCastOp
 //===----------------------------------------------------------------------===//
 
 /// Build a MemRefReinterpretCastOp with all dynamic entries: `staticOffsets`,
 /// `staticSizes` and `staticStrides` are automatically filled with
 /// source-memref-rank sentinel values that encode dynamic entries.
 void mlir::MemRefReinterpretCastOp::build(OpBuilder &b, OperationState &result,
                                           MemRefType resultType, Value source,
-                                          OpFoldResult offset,
-                                          ArrayRef<OpFoldResult> sizes,
-                                          ArrayRef<OpFoldResult> strides,
+                                          ValueOrAttr offset,
+                                          ArrayRef<ValueOrAttr> sizes,
+                                          ArrayRef<ValueOrAttr> strides,
                                           ArrayRef<NamedAttribute> attrs) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
-  dispatchIndexOpFoldResults(offset, dynamicOffsets, staticOffsets,
-                             ShapedType::kDynamicStrideOrOffset);
-  dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
-                             ShapedType::kDynamicSize);
-  dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides,
-                             ShapedType::kDynamicStrideOrOffset);
+  dispatchIndexValueOrAttrs(offset, dynamicOffsets, staticOffsets,
+  dispatchIndexValueOrAttrs(sizes, dynamicSizes, staticSizes,
+  dispatchIndexValueOrAttrs(strides, dynamicStrides, staticStrides,
   build(b, result, resultType, source, dynamicOffsets, dynamicSizes,
         dynamicStrides, b.getI64ArrayAttr(staticOffsets),
         b.getI64ArrayAttr(staticSizes), b.getI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 
 void mlir::MemRefReinterpretCastOp::build(OpBuilder &b, OperationState &result,
                                           MemRefType resultType, Value source,
                                           int64_t offset,
                                           ArrayRef<int64_t> sizes,
                                           ArrayRef<int64_t> strides,
                                           ArrayRef<NamedAttribute> attrs) {
-  SmallVector<OpFoldResult> sizeValues =
-      llvm::to_vector<4>(llvm::map_range(sizes, [&](int64_t v) -> OpFoldResult {
-        return b.getI64IntegerAttr(v);
-      }));
-  SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
-      llvm::map_range(strides, [&](int64_t v) -> OpFoldResult {
+  SmallVector<ValueOrAttr> sizeValues = llvm::to_vector<4>(llvm::map_range(
+      sizes, [&](int64_t v) -> ValueOrAttr { return b.getI64IntegerAttr(v); }));
+  SmallVector<ValueOrAttr> strideValues = llvm::to_vector<4>(
+      llvm::map_range(strides, [&](int64_t v) -> ValueOrAttr {
         return b.getI64IntegerAttr(v);
       }));
   build(b, result, resultType, source, b.getI64IntegerAttr(offset), sizeValues,
         strideValues, attrs);
 }
 
 void mlir::MemRefReinterpretCastOp::build(OpBuilder &b, OperationState &result,
                                           MemRefType resultType, Value source,
                                           Value offset, ValueRange sizes,
                                           ValueRange strides,
                                           ArrayRef<NamedAttribute> attrs) {
-  SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
-      llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
-  SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
-      llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
+  SmallVector<ValueOrAttr> sizeValues = llvm::to_vector<4>(
+      llvm::map_range(sizes, [](Value v) -> ValueOrAttr { return v; }));
+  SmallVector<ValueOrAttr> strideValues = llvm::to_vector<4>(
+      llvm::map_range(strides, [](Value v) -> ValueOrAttr { return v; }));
   build(b, result, resultType, source, offset, sizeValues, strideValues, attrs);
 }
 
 // TODO: ponder whether we want to allow missing trailing sizes/strides that are
 // completed automatically, like we have for subview and subtensor.
 static LogicalResult verify(MemRefReinterpretCastOp op) {
   // The source and result memrefs should be in the same memory space.
   auto srcType = op.source().getType().cast<BaseMemRefType>();
static LogicalResult verify(MemRefReshapeOp op) {
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // MulFOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult MulFOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr MulFOp::fold(ArrayRef<Attribute> operands) {
   return constFoldBinaryOp<FloatAttr>(
       operands, [](APFloat a, APFloat b) { return a * b; });
 }
 
 //===----------------------------------------------------------------------===//
 // MulIOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult MulIOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr MulIOp::fold(ArrayRef<Attribute> operands) {
   /// muli(x, 0) -> 0
   if (matchPattern(rhs(), m_Zero()))
     return rhs();
   /// muli(x, 1) -> x
   if (matchPattern(rhs(), m_One()))
     return getOperand(0);
 
   // TODO: Handle the overflow case.
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a * b; });
 }
 
 //===----------------------------------------------------------------------===//
 // OrOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult OrOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr OrOp::fold(ArrayRef<Attribute> operands) {
   /// or(x, 0) -> x
   if (matchPattern(rhs(), m_Zero()))
     return lhs();
   /// or(x,x) -> x
   if (lhs() == rhs())
     return rhs();
 
   return constFoldBinaryOp<IntegerAttr>(operands,

 static LogicalResult verify(PrefetchOp op) {
   if (op.getNumOperands() != 1 + op.getMemRefType().getRank())
     return op.emitOpError("too few indices");
 
   return success();
 }
 
 LogicalResult PrefetchOp::fold(ArrayRef<Attribute> cstOperands,
-                               SmallVectorImpl<OpFoldResult> &results) {
+                               SmallVectorImpl<ValueOrAttr> &results) {
   // prefetch(memrefcast) -> prefetch
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // RankOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult RankOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr RankOp::fold(ArrayRef<Attribute> operands) {
   // Constant fold rank when the rank of the operand is known.
   auto type = getOperand().getType();
   if (auto shapedType = type.dyn_cast<ShapedType>())
     if (shapedType.hasRank())
       return IntegerAttr::get(IndexType::get(getContext()),
                               shapedType.getRank());
   return IntegerAttr();
 }
static LogicalResult verify(ReturnOp op) {
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SelectOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult SelectOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr SelectOp::fold(ArrayRef<Attribute> operands) {
   auto condition = getCondition();
 
   // select true, %0, %1 => %0
   if (matchPattern(condition, m_One()))
     return getTrueValue();
 
   // select false, %0, %1 => %1
   if (matchPattern(condition, m_Zero()))
static LogicalResult verify(SignExtendIOp op) {
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SignedDivIOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult SignedDivIOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr SignedDivIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "binary operation takes two operands");
 
   // Don't fold if it would overflow or if it requires a division by zero.
   bool overflowOrDiv0 = false;
   auto result = constFoldBinaryOp<IntegerAttr>(operands, [&](APInt a, APInt b) {
     if (overflowOrDiv0 || !b) {
       overflowOrDiv0 = true;
       return a;

 
 static APInt signedCeilNonnegInputs(APInt a, APInt b, bool &overflow) {
   // Returns (a-1)/b + 1
   APInt one(a.getBitWidth(), 1, true); // Signed value 1.
   APInt val = a.ssub_ov(one, overflow).sdiv_ov(b, overflow);
   return val.sadd_ov(one, overflow);
 }
 
-OpFoldResult SignedFloorDivIOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr SignedFloorDivIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "binary operation takes two operands");
 
   // Don't fold if it would overflow or if it requires a division by zero.
   bool overflowOrDiv0 = false;
   auto result = constFoldBinaryOp<IntegerAttr>(operands, [&](APInt a, APInt b) {
     if (overflowOrDiv0 || !b) {
       overflowOrDiv0 = true;
       return a;
ValueOrAttr SignedFloorDivIOp::fold(ArrayRef<Attribute> operands) {
 
   return overflowOrDiv0 ? Attribute() : result;
 }
 
 //===----------------------------------------------------------------------===//
 // SignedCeilDivIOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult SignedCeilDivIOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr SignedCeilDivIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "binary operation takes two operands");
 
   // Don't fold if it would overflow or if it requires a division by zero.
   bool overflowOrDiv0 = false;
   auto result = constFoldBinaryOp<IntegerAttr>(operands, [&](APInt a, APInt b) {
     if (overflowOrDiv0 || !b) {
       overflowOrDiv0 = true;
       return a;
ValueOrAttr SignedCeilDivIOp::fold(ArrayRef<Attribute> operands) {
 
   return overflowOrDiv0 ? Attribute() : result;
 }
 
 //===----------------------------------------------------------------------===//
 // SignedRemIOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult SignedRemIOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr SignedRemIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "remi_signed takes two operands");
 
   auto rhs = operands.back().dyn_cast_or_null<IntegerAttr>();
   if (!rhs)
     return {};
   auto rhsValue = rhs.getValue();
 
   // x % 1 = 0
static LogicalResult verify(SplatOp op) {
   if (op.getOperand().getType() !=
       op.getType().cast<ShapedType>().getElementType())
     return op.emitError("operand should be of elemental type of result type");
 
   return success();
 }
 
 // Constant folding hook for SplatOp.
-OpFoldResult SplatOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr SplatOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 1 && "splat takes one operand");
 
   auto constOperand = operands.front();
   if (!constOperand || !constOperand.isa<IntegerAttr, FloatAttr>())
     return {};
 
   auto shapedType = getType().cast<ShapedType>();
   assert(shapedType.getElementType() == constOperand.getType() &&

 static LogicalResult verify(StoreOp op) {
   if (op.getNumOperands() != 2 + op.getMemRefType().getRank())
     return op.emitOpError("store index operand count not equal to memref rank");
 
   return success();
 }
 
 LogicalResult StoreOp::fold(ArrayRef<Attribute> cstOperands,
-                            SmallVectorImpl<OpFoldResult> &results) {
+                            SmallVectorImpl<ValueOrAttr> &results) {
   /// store(memrefcast) -> store
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // SubFOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult SubFOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr SubFOp::fold(ArrayRef<Attribute> operands) {
   return constFoldBinaryOp<FloatAttr>(
       operands, [](APFloat a, APFloat b) { return a - b; });
 }
 
 //===----------------------------------------------------------------------===//
 // SubIOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult SubIOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr SubIOp::fold(ArrayRef<Attribute> operands) {
   // subi(x,x) -> 0
   if (getOperand(0) == getOperand(1))
     return Builder(getContext()).getZeroAttr(getType());
   // subi(x,0) -> x
   if (matchPattern(rhs(), m_Zero()))
     return lhs();
 
   return constFoldBinaryOp<IntegerAttr>(operands,
Type SubViewOp::inferResultType(MemRefType sourceMemRefType,
   return MemRefType::get(
       staticSizes, sourceMemRefType.getElementType(),
       makeStridedLinearLayoutMap(targetStrides, targetOffset,
                                  sourceMemRefType.getContext()),
       sourceMemRefType.getMemorySpace());
 }
 
 Type SubViewOp::inferResultType(MemRefType sourceMemRefType,
-                                ArrayRef<OpFoldResult> leadingStaticOffsets,
-                                ArrayRef<OpFoldResult> leadingStaticSizes,
-                                ArrayRef<OpFoldResult> leadingStaticStrides) {
+                                ArrayRef<ValueOrAttr> leadingStaticOffsets,
+                                ArrayRef<ValueOrAttr> leadingStaticSizes,
+                                ArrayRef<ValueOrAttr> leadingStaticStrides) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
-  dispatchIndexOpFoldResults(leadingStaticOffsets, dynamicOffsets,
-                             staticOffsets, ShapedType::kDynamicStrideOrOffset);
-  dispatchIndexOpFoldResults(leadingStaticSizes, dynamicSizes, staticSizes,
-                             ShapedType::kDynamicSize);
-  dispatchIndexOpFoldResults(leadingStaticStrides, dynamicStrides,
-                             staticStrides, ShapedType::kDynamicStrideOrOffset);
+  dispatchIndexValueOrAttrs(leadingStaticOffsets, dynamicOffsets, staticOffsets,
+                            ShapedType::kDynamicStrideOrOffset);
+  dispatchIndexValueOrAttrs(leadingStaticSizes, dynamicSizes, staticSizes,
+  dispatchIndexValueOrAttrs(leadingStaticStrides, dynamicStrides, staticStrides,
+                            ShapedType::kDynamicStrideOrOffset);
   return SubViewOp::inferResultType(sourceMemRefType, staticOffsets,
                                     staticSizes, staticStrides)
       .cast<MemRefType>();
 }
 
 // Build a SubViewOp with mixed static and dynamic entries and custom result
 // type. If the type passed is nullptr, it is inferred.
 void mlir::SubViewOp::build(OpBuilder &b, OperationState &result,
                             MemRefType resultType, Value source,
-                            ArrayRef<OpFoldResult> offsets,
-                            ArrayRef<OpFoldResult> sizes,
-                            ArrayRef<OpFoldResult> strides,
+                            ArrayRef<ValueOrAttr> offsets,
+                            ArrayRef<ValueOrAttr> sizes,
+                            ArrayRef<ValueOrAttr> strides,
                             ArrayRef<NamedAttribute> attrs) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
-  dispatchIndexOpFoldResults(offsets, dynamicOffsets, staticOffsets,
-                             ShapedType::kDynamicStrideOrOffset);
-  dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
-                             ShapedType::kDynamicSize);
-  dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides,
-                             ShapedType::kDynamicStrideOrOffset);
+  dispatchIndexValueOrAttrs(offsets, dynamicOffsets, staticOffsets,
+  dispatchIndexValueOrAttrs(sizes, dynamicSizes, staticSizes,
+  dispatchIndexValueOrAttrs(strides, dynamicStrides, staticStrides,
   auto sourceMemRefType = source.getType().cast<MemRefType>();
   // Structuring implementation this way avoids duplication between builders.
   if (!resultType) {
     resultType = SubViewOp::inferResultType(sourceMemRefType, staticOffsets,
                                             staticSizes, staticStrides)
                      .cast<MemRefType>();
   }
   build(b, result, resultType, source, dynamicOffsets, dynamicSizes,
         dynamicStrides, b.getI64ArrayAttr(staticOffsets),
         b.getI64ArrayAttr(staticSizes), b.getI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 
 // Build a SubViewOp with mixed static and dynamic entries and inferred result
 // type.
 void mlir::SubViewOp::build(OpBuilder &b, OperationState &result, Value source,
-                            ArrayRef<OpFoldResult> offsets,
-                            ArrayRef<OpFoldResult> sizes,
-                            ArrayRef<OpFoldResult> strides,
+                            ArrayRef<ValueOrAttr> offsets,
+                            ArrayRef<ValueOrAttr> sizes,
+                            ArrayRef<ValueOrAttr> strides,
                             ArrayRef<NamedAttribute> attrs) {
   build(b, result, MemRefType(), source, offsets, sizes, strides, attrs);
 }
 
 // Build a SubViewOp with static entries and inferred result type.
 void mlir::SubViewOp::build(OpBuilder &b, OperationState &result, Value source,
                             ArrayRef<int64_t> offsets, ArrayRef<int64_t> sizes,
                             ArrayRef<int64_t> strides,
                             ArrayRef<NamedAttribute> attrs) {
-  SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
-      llvm::map_range(offsets, [&](int64_t v) -> OpFoldResult {
-        return b.getI64IntegerAttr(v);
-      }));
-  SmallVector<OpFoldResult> sizeValues =
-      llvm::to_vector<4>(llvm::map_range(sizes, [&](int64_t v) -> OpFoldResult {
+  SmallVector<ValueOrAttr> offsetValues = llvm::to_vector<4>(
+      llvm::map_range(offsets, [&](int64_t v) -> ValueOrAttr {
         return b.getI64IntegerAttr(v);
       }));
-  SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
-      llvm::map_range(strides, [&](int64_t v) -> OpFoldResult {
+  SmallVector<ValueOrAttr> sizeValues = llvm::to_vector<4>(llvm::map_range(
+      sizes, [&](int64_t v) -> ValueOrAttr { return b.getI64IntegerAttr(v); }));
+  SmallVector<ValueOrAttr> strideValues = llvm::to_vector<4>(
+      llvm::map_range(strides, [&](int64_t v) -> ValueOrAttr {
         return b.getI64IntegerAttr(v);
       }));
   build(b, result, source, offsetValues, sizeValues, strideValues, attrs);
 }
 
 // Build a SubViewOp with dynamic entries and custom result type. If the
 // type passed is nullptr, it is inferred.
 void mlir::SubViewOp::build(OpBuilder &b, OperationState &result,
                             MemRefType resultType, Value source,
                             ArrayRef<int64_t> offsets, ArrayRef<int64_t> sizes,
                             ArrayRef<int64_t> strides,
                             ArrayRef<NamedAttribute> attrs) {
-  SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
-      llvm::map_range(offsets, [&](int64_t v) -> OpFoldResult {
-        return b.getI64IntegerAttr(v);
-      }));
-  SmallVector<OpFoldResult> sizeValues =
-      llvm::to_vector<4>(llvm::map_range(sizes, [&](int64_t v) -> OpFoldResult {
+  SmallVector<ValueOrAttr> offsetValues = llvm::to_vector<4>(
+      llvm::map_range(offsets, [&](int64_t v) -> ValueOrAttr {
         return b.getI64IntegerAttr(v);
       }));
-  SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
-      llvm::map_range(strides, [&](int64_t v) -> OpFoldResult {
+  SmallVector<ValueOrAttr> sizeValues = llvm::to_vector<4>(llvm::map_range(
+      sizes, [&](int64_t v) -> ValueOrAttr { return b.getI64IntegerAttr(v); }));
+  SmallVector<ValueOrAttr> strideValues = llvm::to_vector<4>(
+      llvm::map_range(strides, [&](int64_t v) -> ValueOrAttr {
         return b.getI64IntegerAttr(v);
       }));
   build(b, result, resultType, source, offsetValues, sizeValues, strideValues,
         attrs);
 }
 
 // Build a SubViewOp with dynamic entries and custom result type. If the type
 // passed is nullptr, it is inferred.
 void mlir::SubViewOp::build(OpBuilder &b, OperationState &result,
                             MemRefType resultType, Value source,
                             ValueRange offsets, ValueRange sizes,
                             ValueRange strides,
                             ArrayRef<NamedAttribute> attrs) {
-  SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
-      llvm::map_range(offsets, [](Value v) -> OpFoldResult { return v; }));
-  SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
-      llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
-  SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
-      llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
+  SmallVector<ValueOrAttr> offsetValues = llvm::to_vector<4>(
+      llvm::map_range(offsets, [](Value v) -> ValueOrAttr { return v; }));
+  SmallVector<ValueOrAttr> sizeValues = llvm::to_vector<4>(
+      llvm::map_range(sizes, [](Value v) -> ValueOrAttr { return v; }));
+  SmallVector<ValueOrAttr> strideValues = llvm::to_vector<4>(
+      llvm::map_range(strides, [](Value v) -> ValueOrAttr { return v; }));
   build(b, result, resultType, source, offsetValues, sizeValues, strideValues);
 }
 
 // Build a SubViewOp with dynamic entries and inferred result type.
 void mlir::SubViewOp::build(OpBuilder &b, OperationState &result, Value source,
                             ValueRange offsets, ValueRange sizes,
                             ValueRange strides,
                             ArrayRef<NamedAttribute> attrs) {
SmallVector<Range, 8> mlir::getOrCreateRanges(OffsetSizeAndStrideOpInterface op,
   }
   return res;
 }
 
 namespace {
 
 /// Detects the `values` produced by a ConstantIndexOp and places the new
 /// constant in place of the corresponding sentinel value.
-void canonicalizeSubViewPart(SmallVectorImpl<OpFoldResult> &values,
+void canonicalizeSubViewPart(SmallVectorImpl<ValueOrAttr> &values,
                              llvm::function_ref<bool(int64_t)> isDynamic) {
-  for (OpFoldResult &ofr : values) {
+  for (ValueOrAttr &ofr : values) {
     if (ofr.is<Attribute>())
       continue;
     // Newly static, move from Value to constant.
     if (auto cstOp = ofr.dyn_cast<Value>().getDefiningOp<ConstantIndexOp>())
       ofr = OpBuilder(cstOp).getIndexAttr(cstOp.getValue());
   }
 }
 
LogicalResult matchAndRewrite(OpType op,
     // No constant operand, just return;
     if (llvm::none_of(op.getOperands(), [](Value operand) {
           return matchPattern(operand, m_ConstantIndex());
         }))
       return failure();
 
     // At least one of offsets/sizes/strides is a new constant.
     // Form the new list of operands and constant attributes from the existing.
-    SmallVector<OpFoldResult> mixedOffsets(op.getMixedOffsets());
-    SmallVector<OpFoldResult> mixedSizes(op.getMixedSizes());
-    SmallVector<OpFoldResult> mixedStrides(op.getMixedStrides());
+    SmallVector<ValueOrAttr> mixedOffsets(op.getMixedOffsets());
+    SmallVector<ValueOrAttr> mixedSizes(op.getMixedSizes());
+    SmallVector<ValueOrAttr> mixedStrides(op.getMixedStrides());
     canonicalizeSubViewPart(mixedOffsets, ShapedType::isDynamicStrideOrOffset);
     canonicalizeSubViewPart(mixedSizes, ShapedType::isDynamic);
     canonicalizeSubViewPart(mixedStrides, ShapedType::isDynamicStrideOrOffset);
 
     // Create the new op in canonical form.
     auto newOp = rewriter.create<OpType>(op.getLoc(), op.source(), mixedOffsets,
                                          mixedSizes, mixedStrides);
 

 } // namespace
 
 void SubViewOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                             MLIRContext *context) {
   results.insert<OpWithOffsetSizesAndStridesConstantArgumentFolder<SubViewOp>,
                  SubViewOpMemRefCastFolder>(context);
 }
 
-OpFoldResult SubViewOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr SubViewOp::fold(ArrayRef<Attribute> operands) {
   if (getResult().getType().cast<ShapedType>().getRank() == 0 &&
       source().getType().cast<ShapedType>().getRank() == 0)
     return getViewSource();
 
   return {};
 }
 
 //===----------------------------------------------------------------------===//
Type SubTensorOp::inferResultType(RankedTensorType sourceRankedTensorType,
   unsigned numTrailingSizes = rank - staticSizes.size();
   llvm::append_range(staticSizes, sourceRankedTensorType.getShape().take_back(
                                       numTrailingSizes));
   return RankedTensorType::get(staticSizes,
                                sourceRankedTensorType.getElementType());
 }
 
 Type SubTensorOp::inferResultType(RankedTensorType sourceRankedTensorType,
-                                  ArrayRef<OpFoldResult> leadingStaticOffsets,
-                                  ArrayRef<OpFoldResult> leadingStaticSizes,
-                                  ArrayRef<OpFoldResult> leadingStaticStrides) {
+                                  ArrayRef<ValueOrAttr> leadingStaticOffsets,
+                                  ArrayRef<ValueOrAttr> leadingStaticSizes,
+                                  ArrayRef<ValueOrAttr> leadingStaticStrides) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
-  dispatchIndexOpFoldResults(leadingStaticOffsets, dynamicOffsets,
-                             staticOffsets, ShapedType::kDynamicStrideOrOffset);
-  dispatchIndexOpFoldResults(leadingStaticSizes, dynamicSizes, staticSizes,
-                             ShapedType::kDynamicSize);
-  dispatchIndexOpFoldResults(leadingStaticStrides, dynamicStrides,
-                             staticStrides, ShapedType::kDynamicStrideOrOffset);
+  dispatchIndexValueOrAttrs(leadingStaticOffsets, dynamicOffsets, staticOffsets,
+                            ShapedType::kDynamicStrideOrOffset);
+  dispatchIndexValueOrAttrs(leadingStaticSizes, dynamicSizes, staticSizes,
+  dispatchIndexValueOrAttrs(leadingStaticStrides, dynamicStrides, staticStrides,
+                            ShapedType::kDynamicStrideOrOffset);
   return SubTensorOp::inferResultType(sourceRankedTensorType, staticOffsets,
                                       staticSizes, staticStrides)
       .cast<RankedTensorType>();
 }
 
 // Build a SubTensorOp with mixed static and dynamic entries and custom result
 // type. If the type passed is nullptr, it is inferred.
 void mlir::SubTensorOp::build(OpBuilder &b, OperationState &result,
                               RankedTensorType resultType, Value source,
-                              ArrayRef<OpFoldResult> offsets,
-                              ArrayRef<OpFoldResult> sizes,
-                              ArrayRef<OpFoldResult> strides,
+                              ArrayRef<ValueOrAttr> offsets,
+                              ArrayRef<ValueOrAttr> sizes,
+                              ArrayRef<ValueOrAttr> strides,
                               ArrayRef<NamedAttribute> attrs) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
-  dispatchIndexOpFoldResults(offsets, dynamicOffsets, staticOffsets,
-                             ShapedType::kDynamicStrideOrOffset);
-  dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
-                             ShapedType::kDynamicSize);
-  dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides,
-                             ShapedType::kDynamicStrideOrOffset);
+  dispatchIndexValueOrAttrs(offsets, dynamicOffsets, staticOffsets,
+  dispatchIndexValueOrAttrs(sizes, dynamicSizes, staticSizes,
+  dispatchIndexValueOrAttrs(strides, dynamicStrides, staticStrides,
   auto sourceRankedTensorType = source.getType().cast<RankedTensorType>();
   // Structuring implementation this way avoids duplication between builders.
   if (!resultType) {
     resultType =
         SubTensorOp::inferResultType(sourceRankedTensorType, staticOffsets,
                                      staticSizes, staticStrides)
             .cast<RankedTensorType>();
   }
   build(b, result, resultType, source, dynamicOffsets, dynamicSizes,
         dynamicStrides, b.getI64ArrayAttr(staticOffsets),
         b.getI64ArrayAttr(staticSizes), b.getI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 
 // Build a SubTensorOp with mixed static and dynamic entries and inferred result
 // type.
 void mlir::SubTensorOp::build(OpBuilder &b, OperationState &result,
-                              Value source, ArrayRef<OpFoldResult> offsets,
-                              ArrayRef<OpFoldResult> sizes,
-                              ArrayRef<OpFoldResult> strides,
+                              Value source, ArrayRef<ValueOrAttr> offsets,
+                              ArrayRef<ValueOrAttr> sizes,
+                              ArrayRef<ValueOrAttr> strides,
                               ArrayRef<NamedAttribute> attrs) {
   build(b, result, RankedTensorType(), source, offsets, sizes, strides, attrs);
 }
 
 // Build a SubTensorOp with dynamic entries and custom result type. If the type
 // passed is nullptr, it is inferred.
 void mlir::SubTensorOp::build(OpBuilder &b, OperationState &result,
                               RankedTensorType resultType, Value source,
                               ValueRange offsets, ValueRange sizes,
                               ValueRange strides,
                               ArrayRef<NamedAttribute> attrs) {
-  SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
-      llvm::map_range(offsets, [](Value v) -> OpFoldResult { return v; }));
-  SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
-      llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
-  SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
-      llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
+  SmallVector<ValueOrAttr> offsetValues = llvm::to_vector<4>(
+      llvm::map_range(offsets, [](Value v) -> ValueOrAttr { return v; }));
+  SmallVector<ValueOrAttr> sizeValues = llvm::to_vector<4>(
+      llvm::map_range(sizes, [](Value v) -> ValueOrAttr { return v; }));
+  SmallVector<ValueOrAttr> strideValues = llvm::to_vector<4>(
+      llvm::map_range(strides, [](Value v) -> ValueOrAttr { return v; }));
   build(b, result, resultType, source, offsetValues, sizeValues, strideValues);
 }
 
 // Build a SubTensorOp with dynamic entries and inferred result type.
 void mlir::SubTensorOp::build(OpBuilder &b, OperationState &result,
                               Value source, ValueRange offsets,
                               ValueRange sizes, ValueRange strides,
                               ArrayRef<NamedAttribute> attrs) {

 
 //===----------------------------------------------------------------------===//
 // SubTensorInsertOp
 //===----------------------------------------------------------------------===//
 
 // Build a SubTensorInsertOp with mixed static and dynamic entries.
 void mlir::SubTensorInsertOp::build(OpBuilder &b, OperationState &result,
                                     Value source, Value dest,
-                                    ArrayRef<OpFoldResult> offsets,
-                                    ArrayRef<OpFoldResult> sizes,
-                                    ArrayRef<OpFoldResult> strides,
+                                    ArrayRef<ValueOrAttr> offsets,
+                                    ArrayRef<ValueOrAttr> sizes,
+                                    ArrayRef<ValueOrAttr> strides,
                                     ArrayRef<NamedAttribute> attrs) {
   SmallVector<int64_t> staticOffsets, staticSizes, staticStrides;
   SmallVector<Value> dynamicOffsets, dynamicSizes, dynamicStrides;
-  dispatchIndexOpFoldResults(offsets, dynamicOffsets, staticOffsets,
-                             ShapedType::kDynamicStrideOrOffset);
-  dispatchIndexOpFoldResults(sizes, dynamicSizes, staticSizes,
-                             ShapedType::kDynamicSize);
-  dispatchIndexOpFoldResults(strides, dynamicStrides, staticStrides,
-                             ShapedType::kDynamicStrideOrOffset);
+  dispatchIndexValueOrAttrs(offsets, dynamicOffsets, staticOffsets,
+  dispatchIndexValueOrAttrs(sizes, dynamicSizes, staticSizes,
+  dispatchIndexValueOrAttrs(strides, dynamicStrides, staticStrides,
   build(b, result, dest.getType(), source, dest, dynamicOffsets, dynamicSizes,
         dynamicStrides, b.getI64ArrayAttr(staticOffsets),
         b.getI64ArrayAttr(staticSizes), b.getI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 
 // Build a SubTensorInsertOp with dynamic entries.
 void mlir::SubTensorInsertOp::build(OpBuilder &b, OperationState &result,
                                     Value source, Value dest,
                                     ValueRange offsets, ValueRange sizes,
                                     ValueRange strides,
                                     ArrayRef<NamedAttribute> attrs) {
-  SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
-      llvm::map_range(offsets, [](Value v) -> OpFoldResult { return v; }));
-  SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
-      llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
-  SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
-      llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
+  SmallVector<ValueOrAttr> offsetValues = llvm::to_vector<4>(
+      llvm::map_range(offsets, [](Value v) -> ValueOrAttr { return v; }));
+  SmallVector<ValueOrAttr> sizeValues = llvm::to_vector<4>(
+      llvm::map_range(sizes, [](Value v) -> ValueOrAttr { return v; }));
+  SmallVector<ValueOrAttr> strideValues = llvm::to_vector<4>(
+      llvm::map_range(strides, [](Value v) -> ValueOrAttr { return v; }));
   build(b, result, source, dest, offsetValues, sizeValues, strideValues);
 }
 
 //===----------------------------------------------------------------------===//
 // TensorLoadOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult TensorLoadOp::fold(ArrayRef<Attribute>) {
+ValueOrAttr TensorLoadOp::fold(ArrayRef<Attribute>) {
   if (auto tensorToMemref = memref().getDefiningOp<TensorToMemrefOp>())
     return tensorToMemref.tensor();
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // TensorToMemrefOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult TensorToMemrefOp::fold(ArrayRef<Attribute>) {
+ValueOrAttr TensorToMemrefOp::fold(ArrayRef<Attribute>) {
   if (auto tensorLoad = tensor().getDefiningOp<TensorLoadOp>())
     if (tensorLoad.memref().getType() == getType())
       return tensorLoad.memref();
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
static LogicalResult verify(TransposeOp op) {
   auto transposedType = inferTransposeResultType(srcType, op.permutation());
   if (dstType != transposedType)
     return op.emitOpError("output type ")
            << dstType << " does not match transposed input type " << srcType
            << ", " << transposedType;
   return success();
 }
 
-OpFoldResult TransposeOp::fold(ArrayRef<Attribute>) {
+ValueOrAttr TransposeOp::fold(ArrayRef<Attribute>) {
   if (succeeded(foldMemRefCast(*this)))
     return getResult();
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // TruncateIOp
 //===----------------------------------------------------------------------===//
static LogicalResult verify(TruncateIOp op) {
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // UnsignedDivIOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult UnsignedDivIOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr UnsignedDivIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "binary operation takes two operands");
 
   // Don't fold if it would require a division by zero.
   bool div0 = false;
   auto result = constFoldBinaryOp<IntegerAttr>(operands, [&](APInt a, APInt b) {
     if (div0 || !b) {
       div0 = true;
       return a;
ValueOrAttr UnsignedDivIOp::fold(ArrayRef<Attribute> operands) {
 
   return div0 ? Attribute() : result;
 }
 
 //===----------------------------------------------------------------------===//
 // UnsignedRemIOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult UnsignedRemIOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr UnsignedRemIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "remi_unsigned takes two operands");
 
   auto rhs = operands.back().dyn_cast_or_null<IntegerAttr>();
   if (!rhs)
     return {};
   auto rhsValue = rhs.getValue();
 
   // x % 1 = 0
void ViewOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                          MLIRContext *context) {
   results.insert<ViewOpShapeFolder, ViewOpMemrefCastFolder>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // XOrOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult XOrOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr XOrOp::fold(ArrayRef<Attribute> operands) {
   /// xor(x, 0) -> x
   if (matchPattern(rhs(), m_Zero()))
     return lhs();
   /// xor(x,x) -> 0
   if (lhs() == rhs())
     return Builder(getContext()).getZeroAttr(getType());
 
   return constFoldBinaryOp<IntegerAttr>(operands,

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

public:
 
   LogicalResult matchAndRewrite(MemRefReshapeOp op,
                                 PatternRewriter &rewriter) const final {
     auto shapeType = op.shape().getType().cast<MemRefType>();
     if (!shapeType.hasStaticShape())
       return failure();
 
     int64_t rank = shapeType.cast<MemRefType>().getDimSize(0);
-    SmallVector<OpFoldResult, 4> sizes, strides;
+    SmallVector<ValueOrAttr, 4> sizes, strides;
     sizes.resize(rank);
     strides.resize(rank);
 
     Location loc = op.getLoc();
     Value stride = rewriter.create<ConstantIndexOp>(loc, 1);
     for (int i = rank - 1; i >= 0; --i) {
       Value index = rewriter.create<ConstantIndexOp>(loc, i);
       Value size = rewriter.create<LoadOp>(loc, op.shape(), index);

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

static LogicalResult verify(ExtractOp op) {
   // Verify the # indices match if we have a ranked type.
   if (auto tensorType = op.tensor().getType().dyn_cast<RankedTensorType>())
     if (tensorType.getRank() != static_cast<int64_t>(op.indices().size()))
       return op.emitOpError("incorrect number of indices for extract_element");
 
   return success();
 }
 
-OpFoldResult ExtractOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr ExtractOp::fold(ArrayRef<Attribute> operands) {
   // The tensor operand must be a known constant.
   Attribute tensor = operands.front();
   if (!tensor)
     return {};
   // If this is a splat elements attribute, simply return the value. All of the
   // elements of a splat attribute are the same.
   if (auto splatTensor = tensor.dyn_cast<SplatElementsAttr>())
     return splatTensor.getSplatValue();

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

if (value.isa<ElementsAttr>())
     return builder.create<tosa::ConstOp>(loc, type, value.cast<ElementsAttr>());
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator Folders.
 //===----------------------------------------------------------------------===//
 
-OpFoldResult ConstOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr ConstOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.empty() && "constant has no operands");
   return valueAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // TOSA Operator Verifiers.
 //===----------------------------------------------------------------------===//
 

mlir/lib/Dialect/Vector/VectorOps.cpp

static Value foldExtractFromShapeCast(ExtractOp extractOp) {
   // OpBuilder is only used as a helper to build an I64ArrayAttr.
   OpBuilder b(extractOp.getContext());
   extractOp->setAttr(ExtractOp::getPositionAttrName(),
                      b.getI64ArrayAttr(newPosition));
   extractOp.setOperand(shapeCastOp.source());
   return extractOp.getResult();
 }
 
-OpFoldResult ExtractOp::fold(ArrayRef<Attribute>) {
+ValueOrAttr ExtractOp::fold(ArrayRef<Attribute>) {
   if (succeeded(foldExtractOpFromExtractChain(*this)))
     return getResult();
   if (succeeded(foldExtractOpFromTranspose(*this)))
     return getResult();
   if (auto val = foldExtractOpFromInsertChainAndTranspose(*this))
     return val;
   if (auto val = foldExtractFromBroadcast(*this))
     return val;
   if (auto val = foldExtractFromShapeCast(*this))
     return val;
-  return OpFoldResult();
+  return ValueOrAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // ExtractSlicesOp
 //===----------------------------------------------------------------------===//
 
 void ExtractSlicesOp::build(OpBuilder &builder, OperationState &result,
                             TupleType tupleType, Value vector,
if (op.getSourceVectorType().getDimSize(i) !=
       numId++;
   }
   if (numId != op.ids().size())
     return op.emitOpError("expected number of ids must match the number of "
                           "dimensions distributed");
   return success();
 }
 
-OpFoldResult ExtractMapOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr ExtractMapOp::fold(ArrayRef<Attribute> operands) {
   auto insert = vector().getDefiningOp<vector::InsertMapOp>();
   if (insert == nullptr || getType() != insert.vector().getType() ||
       ids() != insert.ids())
     return {};
   return insert.vector();
 }
 
 void ExtractMapOp::getMultiplicity(SmallVectorImpl<int64_t> &multiplicity) {
for (int64_t r = 0; r < srcRank; ++r) {
       if (srcDim != 1 && srcDim != dstDim)
         return op.emitOpError("dimension mismatch (")
                << srcDim << " vs. " << dstDim << ")";
     }
   }
   return success();
 }
 
-OpFoldResult BroadcastOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr BroadcastOp::fold(ArrayRef<Attribute> operands) {
   if (!operands[0])
     return {};
   auto vectorType = getVectorType();
   if (operands[0].getType().isIntOrIndexOrFloat())
     return DenseElementsAttr::get(vectorType, operands[0]);
   if (auto attr = operands[0].dyn_cast<SplatElementsAttr>())
     return DenseElementsAttr::get(vectorType, attr.getSplatValue());
   return {};
else {
       // The extracted vector partially overlap the inserted vector, we cannot
       // fold.
       return failure();
     }
   }
   return failure();
 }
 
-OpFoldResult ExtractStridedSliceOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr ExtractStridedSliceOp::fold(ArrayRef<Attribute> operands) {
   if (getVectorType() == getResult().getType())
     return vector();
   if (succeeded(foldExtractStridedOpFromInsertChain(*this)))
     return getResult();
   return {};
 }
 
 void ExtractStridedSliceOp::getOffsets(SmallVectorImpl<int64_t> &results) {
static LogicalResult foldTransferMaskAttribute(TransferOp op) {
   if (!changed)
     return failure();
   // OpBuilder is only used as a helper to build an I64ArrayAttr.
   OpBuilder b(op.getContext());
   op->setAttr(TransferOp::getMaskedAttrName(), b.getBoolArrayAttr(isMasked));
   return success();
 }
 
-OpFoldResult TransferReadOp::fold(ArrayRef<Attribute>) {
+ValueOrAttr TransferReadOp::fold(ArrayRef<Attribute>) {
   /// transfer_read(memrefcast) -> transfer_read
   if (succeeded(foldTransferMaskAttribute(*this)))
     return getResult();
   if (succeeded(foldMemRefCast(*this)))
     return getResult();
-  return OpFoldResult();
+  return ValueOrAttr();
 }
 
 Optional<SmallVector<int64_t, 4>> TransferReadOp::getShapeForUnroll() {
   auto s = getVectorType().getShape();
   return SmallVector<int64_t, 4>{s.begin(), s.end()};
 }
 
 void TransferReadOp::getEffects(
if (failed(verifyTransferOp(op.getOperation(), shapedType, vectorType,
                               op.masked() ? *op.masked() : ArrayAttr())))
     return failure();
 
   return verifyPermutationMap(permutationMap,
                               [&op](Twine t) { return op.emitOpError(t); });
 }
 
 LogicalResult TransferWriteOp::fold(ArrayRef<Attribute>,
-                                    SmallVectorImpl<OpFoldResult> &) {
+                                    SmallVectorImpl<ValueOrAttr> &) {
   if (succeeded(foldTransferMaskAttribute(*this)))
     return success();
   return foldMemRefCast(*this);
 }
 
 Optional<SmallVector<int64_t, 4>> TransferWriteOp::getShapeForUnroll() {
   return llvm::to_vector<4>(getVectorType().getShape());
 }
for (unsigned i = 0, e = sourceTupleType.size(); i < e; ++i)
     if (failed(verifyVectorShapeCast(
             op, sourceTupleType.getType(i).cast<VectorType>(),
             resultTupleType.getType(i).cast<VectorType>())))
       return failure();
 
   return success();
 }
 
-OpFoldResult ShapeCastOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr ShapeCastOp::fold(ArrayRef<Attribute> operands) {
   // Nop shape cast.
   if (source().getType() == result().getType())
     return source();
 
   // Canceling shape casts.
   if (auto otherOp = source().getDefiningOp<ShapeCastOp>()) {
     if (result().getType() == otherOp.source().getType())
       return otherOp.source();
if (sourceVectorType.getElementTypeBitWidth() *
       resultVectorType.getElementTypeBitWidth() *
           resultVectorType.getShape().back())
     return op.emitOpError(
         "source/result bitwidth of the minor 1-D vectors must be equal");
 
   return success();
 }
 
-OpFoldResult BitCastOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr BitCastOp::fold(ArrayRef<Attribute> operands) {
   // Nop cast.
   if (source().getType() == result().getType())
     return source();
 
   // Canceling bitcasts.
   if (auto otherOp = source().getDefiningOp<BitCastOp>())
     if (result().getType() == otherOp.source().getType())
       return otherOp.source();
void vector::TransposeOp::build(OpBuilder &builder, OperationState &result,
   result.addOperands(vector);
   result.addTypes(VectorType::get(transposedShape, vt.getElementType()));
   result.addAttribute(getTranspAttrName(), builder.getI64ArrayAttr(transp));
 }
 
 // Eliminates transpose operations, which produce values identical to their
 // input values. This happens when the dimensions of the input vector remain in
 // their original order after the transpose operation.
-OpFoldResult vector::TransposeOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr vector::TransposeOp::fold(ArrayRef<Attribute> operands) {
   SmallVector<int64_t, 4> transp;
   getTransp(transp);
 
   // Check if the permutation of the dimensions contains sequential values:
   // {0, 1, 2, ...}.
   for (int64_t i = 0, e = transp.size(); i < e; i++) {
     if (transp[i] != i)
       return {};

 static LogicalResult verify(TupleGetOp op) {
   auto tupleType = op.getOperand().getType().cast<TupleType>();
   if (op.getIndex() < 0 ||
       op.getIndex() >= static_cast<int64_t>(tupleType.size()))
     return op.emitOpError("tuple get index out of range");
   return success();
 }
 
-OpFoldResult TupleGetOp::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr TupleGetOp::fold(ArrayRef<Attribute> operands) {
   // Rewrite:
   //    %t = vector.tuple .., %e_i, ..
   //    %x = vector.tuple_get %t, i
   // into:
   //    %t = vector.tuple .., %e_i, ..  // one less use
   //    %x = %e_i
   if (auto tupleOp = getOperand().getDefiningOp<TupleOp>())
     return tupleOp.getOperand(getIndex());

mlir/lib/Dialect/Vector/VectorTransforms.cpp

static Value createScopedSubViewIntersection(VectorTransferOpInterface xferOp,
                                              Value alloc) {
   using namespace edsc::intrinsics;
   int64_t memrefRank = xferOp.getShapedType().getRank();
   // TODO: relax this precondition, will require rank-reducing subviews.
   assert(memrefRank == alloc.getType().cast<MemRefType>().getRank() &&
          "Expected memref rank to match the alloc rank");
   ValueRange leadingIndices =
       xferOp.indices().take_front(xferOp.getLeadingShapedRank());
-  SmallVector<OpFoldResult, 4> sizes;
+  SmallVector<ValueOrAttr, 4> sizes;
   sizes.append(leadingIndices.begin(), leadingIndices.end());
   xferOp.zipResultAndIndexing([&](int64_t resultIdx, int64_t indicesIdx) {
     using MapList = ArrayRef<ArrayRef<AffineExpr>>;
     Value dimMemRef = std_dim(xferOp.source(), indicesIdx);
     Value dimAlloc = std_dim(alloc, resultIdx);
     Value index = xferOp.indices()[indicesIdx];
     AffineExpr i, j, k;
     bindDims(xferOp.getContext(), i, j, k);
     SmallVector<AffineMap, 4> maps =
         AffineMap::inferFromExprList(MapList{{i - j, k}});
     // affine_min(%dimMemRef - %index, %dimAlloc)
     Value affineMin = affine_min(index.getType(), maps[0],
                                  ValueRange{dimMemRef, index, dimAlloc});
     sizes.push_back(affineMin);
   });
 
-  SmallVector<OpFoldResult, 4> indices = llvm::to_vector<4>(llvm::map_range(
-      xferOp.indices(), [](Value idx) -> OpFoldResult { return idx; }));
+  SmallVector<ValueOrAttr, 4> indices = llvm::to_vector<4>(llvm::map_range(
+      xferOp.indices(), [](Value idx) -> ValueOrAttr { return idx; }));
   return std_sub_view(
       xferOp.source(), indices, sizes,
-      SmallVector<OpFoldResult>(memrefRank, OpBuilder(xferOp).getIndexAttr(1)));
+      SmallVector<ValueOrAttr>(memrefRank, OpBuilder(xferOp).getIndexAttr(1)));
 }
 
 /// Given an `xferOp` for which:
 ///   1. `inBoundsCond` and a `compatibleMemRefType` have been computed.
 ///   2. a memref of single vector `alloc` has been allocated.
 /// Produce IR resembling:
 /// ```
 ///    %1:3 = scf.if (%inBounds) {

mlir/lib/IR/Builders.cpp

LogicalResult OpBuilder::tryFold(Operation *op,
 
   // Check to see if any operands to the operation is constant and whether
   // the operation knows how to constant fold itself.
   SmallVector<Attribute, 4> constOperands(op->getNumOperands());
   for (unsigned i = 0, e = op->getNumOperands(); i != e; ++i)
     matchPattern(op->getOperand(i), m_Constant(&constOperands[i]));
 
   // Try to fold the operation.
-  SmallVector<OpFoldResult, 4> foldResults;
+  SmallVector<ValueOrAttr, 4> foldResults;
   if (failed(op->fold(constOperands, foldResults)) || foldResults.empty())
     return cleanupFailure();
 
   // A temporary builder used for creating constants during folding.
   OpBuilder cstBuilder(context);
   SmallVector<Operation *, 1> generatedConstants;
 
   // Populate the results with the folded results.

mlir/lib/IR/BuiltinDialect.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // UnrealizedConversionCastOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 UnrealizedConversionCastOp::fold(ArrayRef<Attribute> attrOperands,
-                                 SmallVectorImpl<OpFoldResult> &foldResults) {
+                                 SmallVectorImpl<ValueOrAttr> &foldResults) {
   OperandRange operands = inputs();
   if (operands.empty())
     return failure();
 
   // Check that the input is a cast with results that all feed into this
   // operation, and operand types that directly match the result types of this
   // operation.
   ResultRange results = outputs();

mlir/lib/IR/Operation.cpp

 
 void Operation::setSuccessor(Block *block, unsigned index) {
   assert(index < getNumSuccessors());
   getBlockOperands()[index].set(block);
 }
 
 /// Attempt to fold this operation using the Op's registered foldHook.
 LogicalResult Operation::fold(ArrayRef<Attribute> operands,
-                              SmallVectorImpl<OpFoldResult> &results) {
+                              SmallVectorImpl<ValueOrAttr> &results) {
   // If we have a registered operation definition matching this one, use it to
   // try to constant fold the operation.
   auto *abstractOp = getAbstractOperation();
   if (abstractOp && succeeded(abstractOp->foldHook(this, operands, results)))
     return success();
 
   // Otherwise, fall back on the dialect hook to handle it.
   Dialect *dialect = getDialect();

 InFlightDiagnostic OpState::emitRemark(const Twine &message) {
   return getOperation()->emitRemark(message);
 }
 
 //===----------------------------------------------------------------------===//
 // Op Trait implementations
 //===----------------------------------------------------------------------===//
 
-OpFoldResult OpTrait::impl::foldIdempotent(Operation *op) {
+ValueOrAttr OpTrait::impl::foldIdempotent(Operation *op) {
   auto *argumentOp = op->getOperand(0).getDefiningOp();
   if (argumentOp && op->getName() == argumentOp->getName()) {
     // Replace the outer operation output with the inner operation.
     return op->getOperand(0);
   }
 
   return {};
 }
 
-OpFoldResult OpTrait::impl::foldInvolution(Operation *op) {
+ValueOrAttr OpTrait::impl::foldInvolution(Operation *op) {
   auto *argumentOp = op->getOperand(0).getDefiningOp();
   if (argumentOp && op->getName() == argumentOp->getName()) {
     // Replace the outer involutions output with inner's input.
     return argumentOp->getOperand(0);
   }
 
   return {};
 }

 
 //===----------------------------------------------------------------------===//
 // CastOp implementation
 //===----------------------------------------------------------------------===//
 
 /// Attempt to fold the given cast operation.
 LogicalResult
 impl::foldCastInterfaceOp(Operation *op, ArrayRef<Attribute> attrOperands,
-                          SmallVectorImpl<OpFoldResult> &foldResults) {
+                          SmallVectorImpl<ValueOrAttr> &foldResults) {
   OperandRange operands = op->getOperands();
   if (operands.empty())
     return failure();
   ResultRange results = op->getResults();
 
   // Check for the case where the input and output types match 1-1.
   if (operands.getTypes() == results.getTypes()) {
     foldResults.append(operands.begin(), operands.end());

mlir/lib/Transforms/SCCP.cpp

void SCCPSolver::visitOperation(Operation *op) {
   // Save the original operands and attributes just in case the operation folds
   // in-place. The constant passed in may not correspond to the real runtime
   // value, so in-place updates are not allowed.
   SmallVector<Value, 8> originalOperands(op->getOperands());
   DictionaryAttr originalAttrs = op->getAttrDictionary();
 
   // Simulate the result of folding this operation to a constant. If folding
   // fails or was an in-place fold, mark the results as overdefined.
-  SmallVector<OpFoldResult, 8> foldResults;
+  SmallVector<ValueOrAttr, 8> foldResults;
   foldResults.reserve(op->getNumResults());
   if (failed(op->fold(operandConstants, foldResults)))
     return markAllOverdefined(op, op->getResults());
 
   // If the folding was in-place, mark the results as overdefined and reset the
   // operation. We don't allow in-place folds as the desire here is for
   // simulated execution, and not general folding.
   if (foldResults.empty()) {
     op->setOperands(originalOperands);
     op->setAttrs(originalAttrs);
     return markAllOverdefined(op, op->getResults());
   }
 
   // Merge the fold results into the lattice for this operation.
   assert(foldResults.size() == op->getNumResults() && "invalid result size");
   Dialect *opDialect = op->getDialect();
   for (unsigned i = 0, e = foldResults.size(); i != e; ++i) {
     LatticeValue &resultLattice = latticeValues[op->getResult(i)];
 
     // Merge in the result of the fold, either a constant or a value.
-    OpFoldResult foldResult = foldResults[i];
+    ValueOrAttr foldResult = foldResults[i];
     if (Attribute foldAttr = foldResult.dyn_cast<Attribute>())
       meet(op, resultLattice, LatticeValue(foldAttr, opDialect));
     else
       meet(op, resultLattice, latticeValues[foldResult.get<Value>()]);
   }
 }
 
 void SCCPSolver::visitCallableOperation(Operation *op) {

mlir/lib/Transforms/Utils/FoldUtils.cpp

 }
 
 /// Tries to perform folding on the given `op`. If successful, populates
 /// `results` with the results of the folding.
 LogicalResult OperationFolder::tryToFold(
     OpBuilder &builder, Operation *op, SmallVectorImpl<Value> &results,
     function_ref<void(Operation *)> processGeneratedConstants) {
   SmallVector<Attribute, 8> operandConstants;
-  SmallVector<OpFoldResult, 8> foldResults;
+  SmallVector<ValueOrAttr, 8> foldResults;
 
   // If this is a commutative operation, move constants to be trailing operands.
   if (op->getNumOperands() >= 2 && op->hasTrait<OpTrait::IsCommutative>()) {
     std::stable_partition(
         op->getOpOperands().begin(), op->getOpOperands().end(),
         [&](OpOperand &O) { return !matchPattern(O.get(), m_Constant()); });
   }
 
LogicalResult OperationFolder::tryToFold(
   builder.setInsertionPoint(&entry, entry.begin());
 
   // Get the constant map for the insertion region of this operation.
   auto &uniquedConstants = foldScopes[insertRegion];
 
   // Create the result constants and replace the results.
   auto *dialect = op->getDialect();
   for (unsigned i = 0, e = op->getNumResults(); i != e; ++i) {
-    assert(!foldResults[i].isNull() && "expected valid OpFoldResult");
+    assert(!foldResults[i].isNull() && "expected valid ValueOrAttr");
 
     // Check if the result was an SSA value.
     if (auto repl = foldResults[i].dyn_cast<Value>()) {
       if (repl.getType() != op->getResult(i).getType())
         return failure();
       results.emplace_back(repl);
       continue;
     }

mlir/test/lib/Dialect/Test/TestDialect.cpp

 };
 } // end anonymous namespace
 
 void TestOpWithRegionPattern::getCanonicalizationPatterns(
     OwningRewritePatternList &results, MLIRContext *context) {
   results.insert<TestRemoveOpWithInnerOps>(context);
 }
 
-OpFoldResult TestOpWithRegionFold::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr TestOpWithRegionFold::fold(ArrayRef<Attribute> operands) {
   return operand();
 }
 
-OpFoldResult TestOpConstant::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr TestOpConstant::fold(ArrayRef<Attribute> operands) {
   return getValue();
 }
 
 LogicalResult TestOpWithVariadicResultsAndFolder::fold(
-    ArrayRef<Attribute> operands, SmallVectorImpl<OpFoldResult> &results) {
+    ArrayRef<Attribute> operands, SmallVectorImpl<ValueOrAttr> &results) {
   for (Value input : this->operands()) {
     results.push_back(input);
   }
   return success();
 }
 
-OpFoldResult TestOpInPlaceFold::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr TestOpInPlaceFold::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 1);
   if (operands.front()) {
     (*this)->setAttr("attr", operands.front());
     return getResult();
   }
   return {};
 }
 
-OpFoldResult TestPassthroughFold::fold(ArrayRef<Attribute> operands) {
+ValueOrAttr TestPassthroughFold::fold(ArrayRef<Attribute> operands) {
   return getOperand();
 }
 
 LogicalResult OpWithInferTypeInterfaceOp::inferReturnTypes(
     MLIRContext *, Optional<Location> location, ValueRange operands,
     DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType() != operands[1].getType()) {

mlir/test/lib/Dialect/Test/TestTraits.cpp

 
 using namespace mlir;
 using namespace mlir::test;
 
 //===----------------------------------------------------------------------===//
 // Trait Folder.
 //===----------------------------------------------------------------------===//
 
-OpFoldResult TestInvolutionTraitFailingOperationFolderOp::fold(
+ValueOrAttr TestInvolutionTraitFailingOperationFolderOp::fold(
     ArrayRef<Attribute> operands) {
   // This failure should cause the trait fold to run instead.
   return {};
 }
 
-OpFoldResult TestInvolutionTraitSuccesfulOperationFolderOp::fold(
+ValueOrAttr TestInvolutionTraitSuccesfulOperationFolderOp::fold(
     ArrayRef<Attribute> operands) {
   auto argumentOp = getOperand();
   // The success case should cause the trait fold to be supressed.
-  return argumentOp.getDefiningOp() ? argumentOp : OpFoldResult{};
+  return argumentOp.getDefiningOp() ? argumentOp : ValueOrAttr{};
 }
 
 namespace {
 struct TestTraitFolder : public PassWrapper<TestTraitFolder, FunctionPass> {
   void runOnFunction() override {
     (void)applyPatternsAndFoldGreedily(getFunction(),
                                        OwningRewritePatternList());
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
 void registerTestTraitsPass() {
   PassRegistration<TestTraitFolder>("test-trait-folder", "Run trait folding");
 }
 } // namespace mlir

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

 // CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, int integer = 0);
 // CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::TypeRange s, ::mlir::Value a, ::mlir::ValueRange b, ::mlir::IntegerAttr attr1, /*optional*/::mlir::FloatAttr attr2, unsigned someRegionsCount)
 // CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::TypeRange s, ::mlir::Value a, ::mlir::ValueRange b, uint32_t attr1, /*optional*/::mlir::FloatAttr attr2, unsigned someRegionsCount)
 // CHECK:   static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes, unsigned numRegions)
 // CHECK:   static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
 // CHECK:   void print(::mlir::OpAsmPrinter &p);
 // CHECK:   ::mlir::LogicalResult verify();
 // CHECK:   static void getCanonicalizationPatterns(::mlir::OwningRewritePatternList &results, ::mlir::MLIRContext *context);
-// CHECK:   ::mlir::LogicalResult fold(::llvm::ArrayRef<::mlir::Attribute> operands, ::llvm::SmallVectorImpl<::mlir::OpFoldResult> &results);
+// CHECK:   ::mlir::LogicalResult fold(::llvm::ArrayRef<::mlir::Attribute> operands, ::llvm::SmallVectorImpl<::mlir::ValueOrAttr> &results);
 // CHECK:   // Display a graph for debugging purposes.
 // CHECK:   void displayGraph();
 // CHECK: };
 
 // Check AttrSizedOperandSegments
 // ---
 
 def NS_AttrSizedOperandOp : NS_Op<"attr_sized_operands",

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

void TCParser::printCanonicalizersAndFolders(llvm::raw_ostream &os,
   const char *canonicalizersAndFoldersFmt = R"FMT(
     void {0}::getCanonicalizationPatterns(
         OwningRewritePatternList &results,
         MLIRContext *context) {{
       results.insert<EraseDeadLinalgOp>();
       results.insert<FoldTensorCastOp>();
     }
     LogicalResult {0}::fold(ArrayRef<Attribute>,
-                            SmallVectorImpl<OpFoldResult> &) {{
+                            SmallVectorImpl<ValueOrAttr> &) {{
       return foldMemRefCast(*this);
     }
     void {0}::getEffects(SmallVectorImpl<
         SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) {{
       getGenericEffectsImpl(effects,
         getOperation()->getResults(), getInputBuffers(), getOutputBuffers());
     })FMT";
   os << llvm::formatv(canonicalizersAndFoldersFmt, cppOpName);

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 
 void OpEmitter::genFolderDecls() {
   bool hasSingleResult =
       op.getNumResults() == 1 && op.getNumVariableLengthResults() == 0;
 
   if (def.getValueAsBit("hasFolder")) {
     if (hasSingleResult) {
       opClass.addMethodAndPrune(
-          "::mlir::OpFoldResult", "fold", OpMethod::MP_Declaration,
+          "::mlir::ValueOrAttr", "fold", OpMethod::MP_Declaration,
           "::llvm::ArrayRef<::mlir::Attribute>", "operands");
     } else {
       SmallVector<OpMethodParameter, 2> paramList;
       paramList.emplace_back("::llvm::ArrayRef<::mlir::Attribute>", "operands");
-      paramList.emplace_back("::llvm::SmallVectorImpl<::mlir::OpFoldResult> &",
+      paramList.emplace_back("::llvm::SmallVectorImpl<::mlir::ValueOrAttr> &",
                              "results");
       opClass.addMethodAndPrune("::mlir::LogicalResult", "fold",
                                 OpMethod::MP_Declaration, std::move(paramList));
     }
   }
 }
 
 void OpEmitter::genOpInterfaceMethods(const tblgen::InterfaceOpTrait *opTrait) {