[mlir][IR] Add RankedShapedType interface

[springerm]

Summary

RankedShapedType is a sub-interface of ShapedType and implemented by RankedTensorType, MemRefType and VectorType. Interface methods and helper methods that only make sense for ranked types are moved to RankedShapedType. ShapedType now only has interface methods and helper functions that are guaranteed to be supported by the type (no more failed runtime assertions).

RFC: https://discourse.llvm.org/t/rfc-shapedtype-type-interface-cleanup/69998

Depends On: D148488

[mehdi_amini]

The pre-merge checks indicates some legit issues in Flang I believe.

[springerm]

fix flang failures

[springerm]

fix flang failures

[rkayaith]

mlir/include/mlir/IR/BuiltinTypeInterfaces.td

86–97

hasRank doesn't make sense as a method here, since it should always be true

[springerm]

update

[mehdi_amini]

Overall this LGTM, but I think we should wait for the RFC to get enough attention first (and other people to have a more careful look here as well maybe)

mlir/include/mlir/IR/BuiltinTypeInterfaces.td

101

Nit maybe, but you wrote "or not statically known" like if there is a difference from "dynamic", do you intend it? If so what is the difference?

112–113

The comment needs an update

134

Can you update the comment to indicate the behavior in case of dynamic shapes?

134–135

This method looks dangerous to me because of this caveat right now :(

It also does not seem easy to use before of the caveat mentioned below ("if its elemental type does not have a known bit width" without more precision about what element types are handled).

[springerm]

mlir/include/mlir/IR/BuiltinTypeInterfaces.td

134–135

Should this be an interface method? Tensor types don't materialize in memory, so there's no widening. I think this only applies to MemRefType and VectorType.

[springerm]

address comments

[rriddle]

mlir/include/mlir/IR/BuiltinAttributes.td

248–252

390–394

Please reflow this as suggested above.

845–850

Same here and elsewhere.

mlir/include/mlir/IR/BuiltinTypeInterfaces.td

134–135

Yes, IMO ideally this should be killed off. It's a relic from the pre-interface days.

mlir/include/mlir/IR/BuiltinTypes.td

379–381

mlir/lib/AsmParser/AttributeParser.cpp

1053–1060

I don't think there is much value is having multiple casts here

[springerm]

rebase and address comments

[springerm]

address comments

[mehdi_amini]

mlir/include/mlir/IR/BuiltinTypeInterfaces.td

134–135

It probably should also be its own interface or somehow be part of the DL dialect to be properly supported?

[aartbik]

The changes to sparse module are all rather mechanical, so LGTM for that, assuming other reviewers approve the overall change

[ataheridezfouli-groq]

Could you please expose the python bindings for the RankedShapedType interface. My downstream project uses ShapedType from python quite a bit and moving all its methods without exposing RankedShapedType will break a lot of code.

[springerm]

update CAPI and Python bindings

[springerm]

clang-format

[rkayaith]

mlir/include/mlir/IR/BuiltinTypeInterfaces.td

145–148

would it make sense to return kDynamic instead of aborting?

mlir/lib/Bindings/Python/IRTypes.cpp

337–342 ↗

(On Diff #514506)

The existing API seemed to be idiomatic for python, I'm not sure these needed to be removed from the ShapedType bindings (though better docstrings indicating they may fail would be great).

mlir/lib/CAPI/IR/BuiltinTypes.cpp

177

[springerm]

address comments

[springerm]

mlir/include/mlir/IR/BuiltinTypeInterfaces.td

145–148

I put this in a separate revision because the change is unrelated to this refactoring: D148605

mlir/include/mlir/IR/BuiltinTypes.td

379–381

I reformatted this so that it fits in two lines. Let me know if it should be formatted differently.

mlir/lib/Bindings/Python/IRTypes.cpp

337–342 ↗

(On Diff #514506)

I added back the get_rank property.

I think there's no benefit in keeping the other ones on ShapedType because they would always fail on unranked types. Now they just fail with a different error (method does not exist vs. exception). Python is dynamically typed, so any method can be called on any object, we don't need them on ShapedType to make the type checker happy.

[rkayaith]

mlir/lib/Bindings/Python/IRTypes.cpp

337–342 ↗

(On Diff #514506)

ah you're right, I forgot there's not direct TensorType equivalent in the bindings.

[springerm]

rebase

[springerm]

I'm going to break this up into smaller chunks to make it easier to review.

flang/include/flang/Optimizer/Dialect/FIRTypes.td

let extraClassDeclaration = [{
     static CharacterType getSingleton(mlir::MLIRContext *ctxt, KindTy kind) {
       return get(ctxt, kind, singleton());
     }
 
     /// Character is a singleton and has a LEN of 1.
     static constexpr LenType singleton() { return 1; }
 
     /// Character has a LEN value which is not a compile-time known constant.
-    static constexpr LenType unknownLen() { return mlir::ShapedType::kDynamic; }
+    static constexpr LenType unknownLen() {
+      return mlir::RankedShapedType::kDynamic;
+    }
 
     /// Character LEN is a runtime value.
     bool hasDynamicLen() { return getLen() == unknownLen(); }
 
     /// Character LEN is a compile-time constant value.
     bool hasConstantLen() { return !hasDynamicLen(); }
   }];
 }
bool hasDynamicExtents() const {
       return false;
     }
 
     // Does the sequence have unknown shape? (`array<* x T>`)
     bool hasUnknownShape() const { return getShape().empty(); }
 
     // The value `kDynamic` represents an unknown extent for a dimension
     static constexpr Extent getUnknownExtent() {
-      return mlir::ShapedType::kDynamic;
+      return mlir::RankedShapedType::kDynamic;
     }
   }];
 }
 
 def fir_SliceType : FIR_Type<"Slice", "slice"> {
   let summary = "FIR slice";
 
   let description = [{

flang/include/flang/Optimizer/HLFIR/HLFIROpBase.td

let extraClassDeclaration = [{
     mlir::Type getElementExprType() const {
       mlir::Type eleTy = getElementType();
       if (fir::isa_trivial(eleTy))
         return eleTy;
       return hlfir::ExprType::get(eleTy.getContext(), Shape{}, eleTy,
                 isPolymorphic());
     }
     static constexpr int64_t getUnknownExtent() {
-      return mlir::ShapedType::kDynamic;
+      return mlir::RankedShapedType::kDynamic;
     }
   }];
 
   let hasCustomAssemblyFormat = 1;
 
 }
 
 def IsFortranVariablePred

flang/lib/Optimizer/Transforms/AffinePromotion.cpp

createAffineOps(mlir::Value arrayRef, mlir::PatternRewriter &rewriter) {
   SmallVector<mlir::Value> indexArgs;
   indexArgs.append(acoOp.getIndices().begin(), acoOp.getIndices().end());
 
   populateIndexArgs(acoOp, indexArgs, rewriter);
 
   auto affineApply = rewriter.create<mlir::AffineApplyOp>(acoOp.getLoc(),
                                                           affineMap, indexArgs);
   auto arrayElementType = coordinateArrayElement(acoOp);
-  auto newType =
-      mlir::MemRefType::get({mlir::ShapedType::kDynamic}, arrayElementType);
+  auto newType = mlir::MemRefType::get({mlir::RankedShapedType::kDynamic},
+                                       arrayElementType);
   auto arrayConvert = rewriter.create<fir::ConvertOp>(acoOp.getLoc(), newType,
                                                       acoOp.getMemref());
   return std::make_pair(affineApply, arrayConvert);
 }
 
 static void rewriteLoad(fir::LoadOp loadOp, mlir::PatternRewriter &rewriter) {
   rewriter.setInsertionPoint(loadOp);
   auto affineOps = createAffineOps(loadOp.getMemref(), rewriter);

mlir/include/mlir/Dialect/Bufferization/IR/BufferizationOps.td

let extraClassDeclaration = [{
     // the tensor at dimension `idx`. Asserts that the shape is
     // dynamic at that `idx`.
     unsigned getIndexOfDynamicSize(unsigned idx) {
       assert(!getCopy() && "no dim sizes specified when copying a tensor");
       assert(isDynamicDim(idx) && "expected dynamic size");
       ArrayRef<int64_t> shape = getType().getShape();
       return std::count_if(
           shape.begin(), shape.begin() + idx,
-          [&](int64_t size) { return ShapedType::isDynamic(size); });
+          [&](int64_t size) { return RankedShapedType::isDynamic(size); });
     }
 
     // Return the Value of the dynamic size of the tensor at dimension
     // `idx`. Asserts that the shape is dynamic at that `idx.
     Value getDynamicSize(OpBuilder &b, unsigned idx);
 
     // Assert that the size of the result tensor is static at `idx`
     // and return the shape.

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

InterfaceMethod<
       }],
       /*retTy=*/"int64_t",
       /*methodName=*/"getRank",
       /*args=*/(ins "OpOperand*":$opOperand),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(opOperand->getOwner() == this->getOperation());
         if (auto shapedType =
-              opOperand->get().getType().template dyn_cast<ShapedType>())
+              opOperand->get().getType().template dyn_cast<RankedShapedType>())
           return shapedType.getRank();
         return 0;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the input block arguments of the region.
       }],
InterfaceMethod<
       }],
       /*retTy=*/"ArrayRef<int64_t>",
       /*methodName=*/"getShape",
       /*args=*/(ins "OpOperand*":$opOperand),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(opOperand->getOwner() == this->getOperation());
         if (auto shapedType =
-              opOperand->get().getType().template dyn_cast<ShapedType>())
+              opOperand->get().getType().template dyn_cast<RankedShapedType>())
           return shapedType.getShape();
         return {};
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the block argument for an `opOperand`.
       }],
InterfaceMethod<
       /*desc=*/[{
         Return true if any of the operands has a dynamic shape.
       }],
       /*retTy=*/"bool",
       /*methodName=*/"hasDynamicShape",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return llvm::any_of(getStaticShape(), ShapedType::isDynamic);
+        return llvm::any_of(getStaticShape(), RankedShapedType::isDynamic);
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the name registered for this op when lowering to an external
         library call.
       }],
       /*retTy=*/"std::string",

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

 }
 
 
 //===----------------------------------------------------------------------===//
 // Map op.
 //===----------------------------------------------------------------------===//
 
 def TensorOrMemref :
-  AnyTypeOf<[AnyMemRef, AnyRankedTensor], "", "::mlir::ShapedType">;
+  AnyTypeOf<[AnyMemRef, AnyRankedTensor], "", "::mlir::RankedShapedType">;
 
 def MapOp : LinalgStructuredBase_Op<"map", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmBlockArgumentNames"]>,
     SingleBlockImplicitTerminator<"YieldOp">]> {
   let summary = "Elementwise operations";
   let description = [{
     Models elementwise operations on tensors in terms of arithmetic operations

mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

let description = [{
     * sizes: memref-rank number of sizes which specify the sizes of the result
              "view" memref type.
     * strides: memref-rank number of strides that compose multiplicatively with
                the base memref strides in each dimension.
 
     The representation based on offsets, sizes and strides support a
     partially-static specification via attributes specified through the
     `static_offsets`, `static_sizes` and `static_strides` arguments. A special
-    sentinel value ShapedType::kDynamic encodes that the corresponding entry has
-    a dynamic value.
+    sentinel value RankedShapedType::kDynamic encodes that the corresponding
+    entry has a dynamic value.
 
     A subview operation may additionally reduce the rank of the resulting view
     by removing dimensions that are statically known to be of size 1.
 
     Example 1:
 
     ```mlir
     %0 = memref.alloc() : memref<64x4xf32, affine_map<(d0, d1) -> (d0 * 4 + d1)>>

mlir/include/mlir/Dialect/Shape/IR/Shape.h

 
 namespace mlir {
 class PatternRewriter;
 
 namespace shape {
 
 /// Alias type for extent tensors.
 RankedTensorType getExtentTensorType(MLIRContext *ctx,
-                                     int64_t rank = ShapedType::kDynamic);
+                                     int64_t rank = RankedShapedType::kDynamic);
 
 // Check if a type is an extent tensor, e.g., tensor<?xindex>.
 bool isExtentTensorType(Type);
 
 // Given an input shape Value, try to obtain the shape's values.
 LogicalResult getShapeVec(Value input, SmallVectorImpl<int64_t> &shapeValues);
 
 } // namespace shape
 } // namespace mlir
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Shape/IR/ShapeOps.h.inc"
 
 #include "mlir/Dialect/Shape/IR/ShapeOpsDialect.h.inc"
 
 #endif // MLIR_DIALECT_SHAPE_IR_SHAPE_H

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorType.h

public:
   // conditionals throughout the rest of the class.
   SparseTensorType(RankedTensorType rtp)
       : rtp(rtp), enc(getSparseTensorEncoding(rtp)),
         lvlRank(enc ? enc.getLvlRank() : getDimRank()),
         dim2lvl(enc.hasIdDimOrdering() ? AffineMap() : enc.getDimOrdering()) {
     assert((!isIdentity() || getDimRank() == lvlRank) && "Rank mismatch");
   }
 
-  SparseTensorType(ShapedType stp, SparseTensorEncodingAttr enc)
+  SparseTensorType(RankedShapedType stp, SparseTensorEncodingAttr enc)
       : SparseTensorType(
             RankedTensorType::get(stp.getShape(), stp.getElementType(), enc)) {}
 
   // Copy-assignment would be implicitly deleted (because our fields
   // are const), so we explicitly delete it for clarity.
   SparseTensorType &operator=(const SparseTensorType &) = delete;
   // So we must explicitly define the copy-ctor to silence -Wdeprecated-copy.
   SparseTensorType(const SparseTensorType &) = default;
public:
 
   /// Returns the level-rank.
   Level getLvlRank() const { return lvlRank; }
 
   /// Returns the dimension-shape.
   ArrayRef<DynSize> getDimShape() const { return rtp.getShape(); }
 
   /// Safely looks up the requested dimension-DynSize.  If you intend
-  /// to check the result with `ShapedType::isDynamic`, then see the
+  /// to check the result with `RankedShapedType::isDynamic`, then see the
   /// `getStaticDimSize` method instead.
   DynSize getDynamicDimSize(Dimension d) const {
     assert(d < getDimRank() && "Dimension is out of bounds");
     return getDimShape()[d];
   }
 
   /// Safely looks up the requested dimension-size, mapping dynamic
   /// sizes to `std::nullopt`.
   std::optional<StaticSize> getStaticDimSize(Dimension d) const {
     const DynSize sh = getDynamicDimSize(d);
-    return ShapedType::isDynamic(sh) ? std::nullopt
+    return RankedShapedType::isDynamic(sh) ? std::nullopt
                                            : std::optional<StaticSize>(sh);
   }
 
   /// Returns true if no dimension has dynamic size.
   bool hasStaticDimShape() const { return rtp.hasStaticShape(); }
 
   /// Returns true if any dimension has dynamic size.
   bool hasDynamicDimShape() const { return !hasStaticDimShape(); }
 
   /// Returns true if the given dimension has dynamic size.  If you
   /// intend to call `getDynamicDimSize` based on the result, then see
   /// the `getStaticDimSize` method instead.
   bool isDynamicDim(Dimension d) const {
     // We don't use `rtp.isDynamicDim(d)` because we want the
     // OOB error message to be consistent with `getDynamicDimSize`.
-    return ShapedType::isDynamic(getDynamicDimSize(d));
+    return RankedShapedType::isDynamic(getDynamicDimSize(d));
   }
 
   /// Returns the number of dimensions which have dynamic sizes.
   /// The return type is `int64_t` to maintain consistency with
   /// `ShapedType::Trait<T>::getNumDynamicDims`.
   int64_t getNumDynamicDims() const { return rtp.getNumDynamicDims(); }
 
   DimLevelType getLvlType(Level l) const {

mlir/include/mlir/Dialect/Tensor/IR/TensorOps.td

let description = [{
     * sizes: tensor-rank number of sizes which specify the sizes of the result
              tensor type.
     * strides: tensor-rank number of strides specifying subsampling in each
                dimension.
 
     The representation based on offsets, sizes and strides support a
     partially-static specification via attributes specified through the
     `static_offsets`, `static_sizes` and `static_strides` arguments. A special
-    sentinel value ShapedType::kDynamic encodes that the corresponding entry has
-    a dynamic value.
+    sentinel value RankedShapedType::kDynamic encodes that the corresponding
+    entry has a dynamic value.
 
     After buffer allocation, the "extract_slice" op is expected to lower into a
     memref.subview op.
 
     An extract_slice operation may additionally reduce the rank of the resulting
     tensor by removing dimensions that are statically known to be of size 1.
     This rank-reduction behavior is not required by the op semantics: this
     flexibility allows to progressively drop unit dimensions while lowering
let description = [{
     * sizes: tensor-rank number of sizes which specify the sizes of the source
              tensor type.
     * strides: tensor-rank number of strides that specify subsampling in each
                dimension.
 
     The representation based on offsets, sizes and strides support a
     partially-static specification via attributes specified through the
     `static_offsets`, `static_sizes` and `static_strides` arguments. A special
-    sentinel value ShapedType::kDynamic encodes that the corresponding entry has
-    a dynamic value.
+    sentinel value RankedShapedType::kDynamic encodes that the corresponding
+    entry has a dynamic value.
 
     After buffer allocation, the "insert_slice" op is expected to lower into a
     memref.subview op.
 
     An insert_slice operation may additionally specify insertion into a tensor
     of higher rank than the source tensor, along dimensions that are statically
     known to be of size 1.
     This rank-altering behavior is not required by the op semantics: this
let extraClassDeclaration = [{
     // the op.
     inline SmallVector<OpFoldResult> getMixedPadImpl(ArrayRef<int64_t> staticAttrs,
                                                      ValueRange values) {
       Builder builder(*this);
       SmallVector<OpFoldResult> res;
       unsigned numDynamic = 0;
       unsigned count = staticAttrs.size();
       for (unsigned idx = 0; idx < count; ++idx) {
-        if (ShapedType::isDynamic(staticAttrs[idx]))
+        if (RankedShapedType::isDynamic(staticAttrs[idx]))
           res.push_back(values[numDynamic++]);
         else
           res.push_back(builder.getI64IntegerAttr(staticAttrs[idx]));
       }
       return res;
     }
     SmallVector<OpFoldResult> getMixedLowPad() {
       return getMixedPadImpl(getStaticLow(), getLow());
let description = [{
     * sizes: tensor-rank number of sizes which specify the sizes of the source
              tensor type.
     * strides: tensor-rank number of strides that specify subsampling in each
                dimension.
 
     The representation based on offsets, sizes and strides support a
     partially-static specification via attributes specified through the
     `static_offsets`, `static_sizes` and `static_strides` arguments. A special
-    sentinel value ShapedType::kDynamic encodes that the corresponding entry has
-    a dynamic value.
+    sentinel value RankedShapedType::kDynamic encodes that the corresponding
+    entry has a dynamic value.
 
     After buffer allocation, the "parallel_insert_slice" op is expected to lower
     into a memref.subview op.
 
     A parallel_insert_slice operation may additionally specify insertion into a
     tensor of higher rank than the source tensor, along dimensions that are
     statically known to be of size 1.
     This rank-altering behavior is not required by the op semantics: this

mlir/include/mlir/Dialect/Tosa/Utils/ConversionUtils.h

 bool validIntegerRange(IntegerType ty, int64_t value);
 
 // Checks for a dynamic batch dim in any of the passed parameters of an op.
 // The batch dimention must be #0 and the rest of the dimensions must be static.
 template <typename Op>
 std::optional<SmallVector<Value>>
 checkHasDynamicBatchDims(PatternRewriter &rewriter, Op op,
                          ArrayRef<Value> params) {
-  SmallVector<ShapedType> dynTypes;
+  SmallVector<RankedShapedType> dynTypes;
   SmallVector<Value> dynamicDims;
   for (const Value &param : params) {
-    auto paramTy = param.getType().cast<ShapedType>();
+    auto paramTy = param.getType().cast<RankedShapedType>();
     if (!paramTy.hasStaticShape())
       dynTypes.push_back(paramTy);
   }
 
   if (dynTypes.empty())
     return dynamicDims;
 
-  for (const ShapedType &dynTy : dynTypes) {
-    if (llvm::any_of(dynTy.getShape().drop_front(), ShapedType::isDynamic)) {
+  for (const RankedShapedType &dynTy : dynTypes) {
+    if (llvm::any_of(dynTy.getShape().drop_front(),
+                     RankedShapedType::isDynamic)) {
       (void)rewriter.notifyMatchFailure(
           op, "input can only be dynamic for batch size");
       return std::nullopt;
     }
   }
 
   dynamicDims.push_back(
       rewriter.create<tensor::DimOp>(op->getLoc(), params[0], 0));
   return dynamicDims;
 }
 
 } // namespace tosa
 } // namespace mlir
 
 #endif // DIALECT_TOSA_UTILS_COVERSION_UTILS_H_

mlir/include/mlir/Dialect/Tosa/Utils/ShapeUtils.h

struct ValueKnowledge {
   }
 
   operator bool() const { return !hasError; }
 
   // Get the static knowledge intrinsic to `type`.
   static ValueKnowledge getKnowledgeFromType(Type type) {
     ValueKnowledge result = getPessimisticValueState();
     if (auto shapedType = type.dyn_cast<ShapedType>()) {
-      if (shapedType.hasRank()) {
+      if (auto rankedShapedType = dyn_cast<RankedShapedType>(shapedType)) {
         result.hasRank = true;
-        result.sizes.reserve(shapedType.getRank());
-        for (auto dim : shapedType.getShape())
+        result.sizes.reserve(rankedShapedType.getRank());
+        for (auto dim : rankedShapedType.getShape())
           result.sizes.push_back(dim);
       }
       result.dtype = shapedType.getElementType();
     }
     return result;
   }
 
   // Return a pessimistic/conservative value state without assuming any knowlege
if (!lhs.hasRank) {
       result.sizes = rhs.sizes;
       return result;
     }
 
     if (lhs.sizes.size() != rhs.sizes.size())
       return result;
 
     result.hasRank = true;
-    result.sizes.resize(lhs.sizes.size(), ShapedType::kDynamic);
+    result.sizes.resize(lhs.sizes.size(), RankedShapedType::kDynamic);
     for (auto i : llvm::seq<unsigned>(0, result.sizes.size())) {
       int64_t lhsSize = lhs.sizes[i];
       int64_t rhsSize = rhs.sizes[i];
       int64_t &resultSize = result.sizes[i];
-      if (lhsSize == ShapedType::kDynamic) {
+      if (lhsSize == RankedShapedType::kDynamic) {
         resultSize = rhsSize;
-      } else if (rhsSize == ShapedType::kDynamic) {
+      } else if (rhsSize == RankedShapedType::kDynamic) {
         resultSize = lhsSize;
       } else if (lhsSize == rhsSize) {
         resultSize = lhsSize;
       } else {
         result.hasError = true;
       }
     }
 
static ValueKnowledge meet(const ValueKnowledge &lhs,
     }
 
     if (lhs.sizes.size() != rhs.sizes.size()) {
       result.hasRank = false;
       return result;
     }
 
     result.hasRank = true;
-    result.sizes.resize(lhs.sizes.size(), ShapedType::kDynamic);
+    result.sizes.resize(lhs.sizes.size(), RankedShapedType::kDynamic);
     for (int i = 0, e = lhs.sizes.size(); i < e; i++) {
       if (lhs.sizes[i] == rhs.sizes[i]) {
         result.sizes[i] = lhs.sizes[i];
       }
     }
 
     return result;
   }

mlir/include/mlir/Dialect/Utils/ReshapeOpsUtils.h

 /// Convert Array<Array<AffineExpr>> to Array<Array<int64_t>>.
 SmallVector<ReassociationIndices, 2> convertReassociationMapsToIndices(
     OpBuilder &b, ArrayRef<ReassociationExprs> reassociationExprs);
 
 /// Return the reassociations maps to use to reshape given the source type and
 /// the target type when possible. Return std::nullopt when this computation
 /// failed.
 std::optional<SmallVector<ReassociationIndices>>
-getReassociationIndicesForReshape(ShapedType sourceType, ShapedType targetType);
+getReassociationIndicesForReshape(RankedShapedType sourceType,
+                                  RankedShapedType targetType);
 
 /// Returns the reassociation maps to collapse `sourceShape` to `targetShape` if
 /// possible.
 std::optional<SmallVector<ReassociationIndices>>
 getReassociationIndicesForCollapse(ArrayRef<int64_t> sourceShape,
                                    ArrayRef<int64_t> targetShape);
 
 /// Return true if the reassociation specification is valid, false otherwise.

 ///    corresponding dimensions in the expanded type should be dynamic. This
 ///    rule is only needed with reshape operations that are expanding.
 LogicalResult reshapeLikeShapesAreCompatible(
     function_ref<LogicalResult(const Twine &)> emitError,
     ArrayRef<int64_t> collapsedShape, ArrayRef<int64_t> expandedShape,
     ArrayRef<ReassociationIndices> reassociationMaps, bool isExpandingReshape);
 
 template <typename OpTy>
-static LogicalResult verifyReshapeLikeShapes(OpTy op, ShapedType collapsedType,
-                                             ShapedType expandedType,
+static LogicalResult verifyReshapeLikeShapes(OpTy op,
+                                             RankedShapedType collapsedType,
+                                             RankedShapedType expandedType,
                                              bool isExpandingReshape) {
   return reshapeLikeShapesAreCompatible(
       [&](const Twine &msg) { return op->emitOpError(msg); },
       collapsedType.getShape(), expandedType.getShape(),
       op.getReassociationIndices(), isExpandingReshape);
 }
 
 /// Returns true iff the type is a MemRefType and has a non-identity layout.

 struct ComposeCollapseOfExpandOp : public OpRewritePattern<CollapseOpTy> {
   using OpRewritePattern<CollapseOpTy>::OpRewritePattern;
   LogicalResult matchAndRewrite(CollapseOpTy collapseOp,
                                 PatternRewriter &rewriter) const override {
     auto expandOp = collapseOp.getSrc().template getDefiningOp<ExpandOpTy>();
     if (!expandOp)
       return failure();
 
-    ShapedType srcType = expandOp.getSrcType();
-    ShapedType resultType = collapseOp.getResultType();
+    RankedShapedType srcType = expandOp.getSrcType();
+    RankedShapedType resultType = collapseOp.getResultType();
 
     if (hasNonIdentityLayout(collapseOp.getSrc().getType()) ||
         hasNonIdentityLayout(expandOp.getSrc().getType()) ||
         hasNonIdentityLayout(expandOp.getResult().getType()))
       return failure();
 
     int64_t srcRank = srcType.getRank();
     int64_t resultRank = resultType.getRank();

 struct ComposeExpandOfCollapseOp : public OpRewritePattern<ExpandOpTy> {
   using OpRewritePattern<ExpandOpTy>::OpRewritePattern;
   LogicalResult matchAndRewrite(ExpandOpTy expandOp,
                                 PatternRewriter &rewriter) const override {
     auto collapseOp = expandOp.getSrc().template getDefiningOp<CollapseOpTy>();
     if (!collapseOp)
       return failure();
 
-    ShapedType srcType = collapseOp.getSrcType();
-    ShapedType resultType = expandOp.getResultType();
+    RankedShapedType srcType = collapseOp.getSrcType();
+    RankedShapedType resultType = expandOp.getResultType();
 
     if (hasNonIdentityLayout(expandOp.getSrc().getType()) ||
         hasNonIdentityLayout(collapseOp.getSrc().getType()) ||
         hasNonIdentityLayout(collapseOp.getResult().getType()))
       return failure();
 
     int64_t srcRank = srcType.getRank();
     int64_t resultRank = resultType.getRank();

mlir/include/mlir/Dialect/Utils/StaticValueUtils.h

 //   mlir/include/mlir/Dialect/Arith/Utils/Utils.h
 // TODO: find a better common landing place.
 //
 // SmallVector<Value>
 // getValueOrCreateConstantIndexOp(OpBuilder &b, Location loc,
 //                                 ArrayRef<OpFoldResult> valueOrAttrVec);
 
 /// Return a vector of OpFoldResults with the same size a staticValues, but
-/// all elements for which ShapedType::isDynamic is true, will be replaced by
-/// dynamicValues.
+/// all elements for which RankedShapedType::isDynamic is true, will be replaced
+/// by dynamicValues.
 SmallVector<OpFoldResult> getMixedValues(ArrayRef<int64_t> staticValues,
                                          ValueRange dynamicValues, Builder &b);
 
 /// Decompose a vector of mixed static or dynamic values into the
 /// corresponding pair of arrays. This is the inverse function of
 /// `getMixedValues`.
 std::pair<ArrayAttr, SmallVector<Value>>
 decomposeMixedValues(Builder &b,

mlir/include/mlir/Dialect/Vector/IR/VectorOps.h

 
 /// Return true if the last dimension of the MemRefType has unit stride. Also
 /// return true for memrefs with no strides.
 bool isLastMemrefDimUnitStride(MemRefType type);
 
 /// Build the default minor identity map suitable for a vector transfer. This
 /// also handles the case memref<... x vector<...>> -> vector<...> in which the
 /// rank of the identity map must take the vector element type into account.
-AffineMap getTransferMinorIdentityMap(ShapedType shapedType,
+AffineMap getTransferMinorIdentityMap(RankedShapedType shapedType,
                                       VectorType vectorType);
 
 /// Return true if the transfer_write fully writes the data accessed by the
 /// transfer_read.
 bool checkSameValueRAW(TransferWriteOp defWrite, TransferReadOp read);
 
 /// Return true if the write op fully over-write the priorWrite transfer_write
 /// op.

mlir/include/mlir/IR/BuiltinAttributeInterfaces.td

InterfaceMethod<[{
       Returns true if the attribute elements correspond to a splat, i.e. that
       all elements of the attribute are the same value.
     }], "bool", "isSplat", (ins), /*defaultImplementation=*/[{}], [{
         // By default, only check for a single element splat.
         return $_attr.getNumElements() == 1;
     }]>,
     InterfaceMethod<[{
       Returns the shaped type of the elements attribute.
-    }], "::mlir::ShapedType", "getType">
+    }], "::mlir::RankedShapedType", "getType">
   ];
 
   string ElementsAttrInterfaceAccessors = [{
     /// Return the number of elements held by this attribute.
     int64_t size() const { return getNumElements(); }
 
     /// Return if the attribute holds no elements.
     bool empty() const { return size() == 0; }
let extraClassDeclaration = [{
     /// Return the element type of this ElementsAttr.
     Type getElementType() const { return getElementType(*this); }
     static Type getElementType(ElementsAttr elementsAttr);
 
     /// Return if the given 'index' refers to a valid element in this attribute.
     bool isValidIndex(ArrayRef<uint64_t> index) const {
       return isValidIndex(*this, index);
     }
-    static bool isValidIndex(ShapedType type, ArrayRef<uint64_t> index);
+    static bool isValidIndex(RankedShapedType type, ArrayRef<uint64_t> index);
     static bool isValidIndex(ElementsAttr elementsAttr,
                              ArrayRef<uint64_t> index);
 
     /// Return the 1 dimensional flattened row-major index from the given
     /// multi-dimensional index.
     uint64_t getFlattenedIndex(ArrayRef<uint64_t> index) const {
       return getFlattenedIndex(*this, index);
     }

mlir/include/mlir/IR/BuiltinAttributes.h

public:
 
   /// Method for support type inquiry through isa, cast and dyn_cast.
   static bool classof(Attribute attr);
 
   /// Constructs a dense elements attribute from an array of element values.
   /// Each element attribute value is expected to be an element of 'type'.
   /// 'type' must be a vector or tensor with static shape. If the element of
   /// `type` is non-integer/index/float it is assumed to be a string type.
-  static DenseElementsAttr get(ShapedType type, ArrayRef<Attribute> values);
+  static DenseElementsAttr get(RankedShapedType type,
+                               ArrayRef<Attribute> values);
 
   /// Constructs a dense integer elements attribute from an array of integer
   /// or floating-point values. Each value is expected to be the same bitwidth
   /// of the element type of 'type'. 'type' must be a vector or tensor with
   /// static shape.
   template <typename T,
             typename = std::enable_if_t<std::numeric_limits<T>::is_integer ||
                                         is_valid_cpp_fp_type<T>::value>>
-  static DenseElementsAttr get(const ShapedType &type, ArrayRef<T> values) {
+  static DenseElementsAttr get(const RankedShapedType &type,
+                               ArrayRef<T> values) {
     const char *data = reinterpret_cast<const char *>(values.data());
     return getRawIntOrFloat(
         type, ArrayRef<char>(data, values.size() * sizeof(T)), sizeof(T),
         std::numeric_limits<T>::is_integer, std::numeric_limits<T>::is_signed);
   }
 
   /// Constructs a dense integer elements attribute from a single element.
   template <typename T,
             typename = std::enable_if_t<std::numeric_limits<T>::is_integer ||
                                         is_valid_cpp_fp_type<T>::value ||
                                         detail::is_complex_t<T>::value>>
-  static DenseElementsAttr get(const ShapedType &type, T value) {
+  static DenseElementsAttr get(const RankedShapedType &type, T value) {
     return get(type, llvm::ArrayRef(value));
   }
 
   /// Constructs a dense complex elements attribute from an array of complex
   /// values. Each value is expected to be the same bitwidth of the element type
   /// of 'type'. 'type' must be a vector or tensor with static shape.
   template <
       typename T, typename ElementT = typename T::value_type,
       typename = std::enable_if_t<detail::is_complex_t<T>::value &&
                                   (std::numeric_limits<ElementT>::is_integer ||
                                    is_valid_cpp_fp_type<ElementT>::value)>>
-  static DenseElementsAttr get(const ShapedType &type, ArrayRef<T> values) {
+  static DenseElementsAttr get(const RankedShapedType &type,
+                               ArrayRef<T> values) {
     const char *data = reinterpret_cast<const char *>(values.data());
     return getRawComplex(type, ArrayRef<char>(data, values.size() * sizeof(T)),
                          sizeof(T), std::numeric_limits<ElementT>::is_integer,
                          std::numeric_limits<ElementT>::is_signed);
   }
 
   /// Overload of the above 'get' method that is specialized for boolean values.
-  static DenseElementsAttr get(ShapedType type, ArrayRef<bool> values);
+  static DenseElementsAttr get(RankedShapedType type, ArrayRef<bool> values);
 
   /// Overload of the above 'get' method that is specialized for StringRef
   /// values.
-  static DenseElementsAttr get(ShapedType type, ArrayRef<StringRef> values);
+  static DenseElementsAttr get(RankedShapedType type,
+                               ArrayRef<StringRef> values);
 
   /// Constructs a dense integer elements attribute from an array of APInt
   /// values. Each APInt value is expected to have the same bitwidth as the
   /// element type of 'type'. 'type' must be a vector or tensor with static
   /// shape.
-  static DenseElementsAttr get(ShapedType type, ArrayRef<APInt> values);
+  static DenseElementsAttr get(RankedShapedType type, ArrayRef<APInt> values);
 
   /// Constructs a dense complex elements attribute from an array of APInt
   /// values. Each APInt value is expected to have the same bitwidth as the
   /// element type of 'type'. 'type' must be a vector or tensor with static
   /// shape.
-  static DenseElementsAttr get(ShapedType type,
+  static DenseElementsAttr get(RankedShapedType type,
                                ArrayRef<std::complex<APInt>> values);
 
   /// Constructs a dense float elements attribute from an array of APFloat
   /// values. Each APFloat value is expected to have the same bitwidth as the
   /// element type of 'type'. 'type' must be a vector or tensor with static
   /// shape.
-  static DenseElementsAttr get(ShapedType type, ArrayRef<APFloat> values);
+  static DenseElementsAttr get(RankedShapedType type, ArrayRef<APFloat> values);
 
   /// Constructs a dense complex elements attribute from an array of APFloat
   /// values. Each APFloat value is expected to have the same bitwidth as the
   /// element type of 'type'. 'type' must be a vector or tensor with static
   /// shape.
-  static DenseElementsAttr get(ShapedType type,
+  static DenseElementsAttr get(RankedShapedType type,
                                ArrayRef<std::complex<APFloat>> values);
 
   /// Construct a dense elements attribute for an initializer_list of values.
   /// Each value is expected to be the same bitwidth of the element type of
   /// 'type'. 'type' must be a vector or tensor with static shape.
   template <typename T>
-  static DenseElementsAttr get(const ShapedType &type,
+  static DenseElementsAttr get(const RankedShapedType &type,
                                const std::initializer_list<T> &list) {
     return get(type, ArrayRef<T>(list));
   }
 
   /// Construct a dense elements attribute from a raw buffer representing the
   /// data for this attribute. Users are encouraged to use one of the
   /// constructors above, which provide more safeties. However, this
   /// constructor is useful for tools which may want to interop and can
   /// follow the precise definition.
   ///
   /// The format of the raw buffer is a densely packed array of values that
   /// can be bitcast to the storage format of the element type specified.
   /// Types that are not byte aligned will be:
   ///   - For bitwidth > 1: Rounded up to the next byte.
   ///   - For bitwidth = 1: Packed into 8bit bytes with bits corresponding to
   ///     the linear order of the shape type from MSB to LSB, padded to on the
   ///     right.
-  static DenseElementsAttr getFromRawBuffer(ShapedType type,
+  static DenseElementsAttr getFromRawBuffer(RankedShapedType type,
                                             ArrayRef<char> rawBuffer);
 
   /// Returns true if the given buffer is a valid raw buffer for the given type.
   /// `detectedSplat` is set if the buffer is valid and represents a splat
   /// buffer. The definition may be expanded over time, but currently, a
   /// splat buffer is detected if:
   ///   - For >1bit: The buffer consists of a single element.
   ///   - For 1bit: The buffer consists of a single byte with value 0 or 255.
   ///
   /// User code should be prepared for additional, conformant patterns to be
   /// identified as splats in the future.
-  static bool isValidRawBuffer(ShapedType type, ArrayRef<char> rawBuffer,
+  static bool isValidRawBuffer(RankedShapedType type, ArrayRef<char> rawBuffer,
                                bool &detectedSplat);
 
   //===--------------------------------------------------------------------===//
   // Iterators
   //===--------------------------------------------------------------------===//
 
   /// The iterator range over the given iterator type T.
   template <typename IteratorT>
public:
   /// form the user might expect.
   ArrayRef<char> getRawData() const;
 
   /// Return the raw StringRef data held by this attribute.
   ArrayRef<StringRef> getRawStringData() const;
 
   /// Return the type of this ElementsAttr, guaranteed to be a vector or tensor
   /// with static shape.
-  ShapedType getType() const;
+  RankedShapedType getType() const;
 
   /// Return the element type of this DenseElementsAttr.
   Type getElementType() const;
 
   /// Returns the number of elements held by this attribute.
   int64_t getNumElements() const;
 
   /// Returns the number of elements held by this attribute.
   int64_t size() const { return getNumElements(); }
 
   /// Returns if the number of elements held by this attribute is 0.
   bool empty() const { return size() == 0; }
 
   //===--------------------------------------------------------------------===//
   // Mutation Utilities
   //===--------------------------------------------------------------------===//
 
   /// Return a new DenseElementsAttr that has the same data as the current
   /// attribute, but has been reshaped to 'newType'. The new type must have the
   /// same total number of elements as well as element type.
-  DenseElementsAttr reshape(ShapedType newType);
+  DenseElementsAttr reshape(RankedShapedType newType);
 
   /// Return a new DenseElementsAttr that has the same data as the current
   /// attribute, but with a different shape for a splat type. The new type must
   /// have the same element type.
-  DenseElementsAttr resizeSplat(ShapedType newType);
+  DenseElementsAttr resizeSplat(RankedShapedType newType);
 
   /// Return a new DenseElementsAttr that has the same data as the current
   /// attribute, but has bitcast elements to 'newElType'. The new type must have
   /// the same bitwidth as the current element type.
   DenseElementsAttr bitcast(Type newElType);
 
   /// Generates a new DenseElementsAttr by mapping each int value to a new
   /// underlying APInt. The new values can represent either an integer or float.
protected:
   FailureOr<iterator_range_impl<FloatElementIterator>>
   tryGetFloatValues() const;
   FailureOr<iterator_range_impl<ComplexFloatElementIterator>>
   tryGetComplexFloatValues() const;
 
   /// Overload of the raw 'get' method that asserts that the given type is of
   /// complex type. This method is used to verify type invariants that the
   /// templatized 'get' method cannot.
-  static DenseElementsAttr getRawComplex(ShapedType type, ArrayRef<char> data,
+  static DenseElementsAttr getRawComplex(RankedShapedType type,
+                                         ArrayRef<char> data,
                                          int64_t dataEltSize, bool isInt,
                                          bool isSigned);
 
   /// Overload of the raw 'get' method that asserts that the given type is of
   /// integer or floating-point type. This method is used to verify type
   /// invariants that the templatized 'get' method cannot.
-  static DenseElementsAttr getRawIntOrFloat(ShapedType type,
+  static DenseElementsAttr getRawIntOrFloat(RankedShapedType type,
                                             ArrayRef<char> data,
                                             int64_t dataEltSize, bool isInt,
                                             bool isSigned);
 
   /// Check the information for a C++ data type, check if this type is valid for
   /// the current attribute. This method is used to verify specific type
   /// invariants that the templatized 'getValues' method cannot.
   bool isValidBool() const { return getElementType().isInteger(1); }
public:
   using DenseResourceElementsAttr::DenseResourceElementsAttr;
 
   /// A builder that inserts a new resource using the provided blob. The handle
   /// of the inserted blob is used when building the attribute. The provided
   /// `blobName` is used as a hint for the key of the new handle for the `blob`
   /// resource, but may be changed if necessary to ensure uniqueness during
   /// insertion.
   static DenseResourceElementsAttrBase<T>
-  get(ShapedType type, StringRef blobName, AsmResourceBlob blob);
+  get(RankedShapedType type, StringRef blobName, AsmResourceBlob blob);
 
   /// Return the data of this attribute as an ArrayRef<T> if it is present,
   /// returns std::nullopt otherwise.
   std::optional<ArrayRef<T>> tryGetAsArrayRef() const;
 
   /// Support for isa<>/cast<>.
   static bool classof(Attribute attr);
 };

 public:
   using iterator = DenseElementsAttr::FloatElementIterator;
 
   using DenseIntOrFPElementsAttr::DenseIntOrFPElementsAttr;
 
   /// Get an instance of a DenseFPElementsAttr with the given arguments. This
   /// simply wraps the DenseElementsAttr::get calls.
   template <typename Arg>
-  static DenseFPElementsAttr get(const ShapedType &type, Arg &&arg) {
+  static DenseFPElementsAttr get(const RankedShapedType &type, Arg &&arg) {
     return DenseElementsAttr::get(type, llvm::ArrayRef(arg))
         .template cast<DenseFPElementsAttr>();
   }
   template <typename T>
-  static DenseFPElementsAttr get(const ShapedType &type,
+  static DenseFPElementsAttr get(const RankedShapedType &type,
                                  const std::initializer_list<T> &list) {
     return DenseElementsAttr::get(type, list)
         .template cast<DenseFPElementsAttr>();
   }
 
   /// Generates a new DenseElementsAttr by mapping each value attribute, and
   /// constructing the DenseElementsAttr given the new element type.
   DenseElementsAttr
public:
   /// iterator directly.
   using iterator = DenseElementsAttr::IntElementIterator;
 
   using DenseIntOrFPElementsAttr::DenseIntOrFPElementsAttr;
 
   /// Get an instance of a DenseIntElementsAttr with the given arguments. This
   /// simply wraps the DenseElementsAttr::get calls.
   template <typename Arg>
-  static DenseIntElementsAttr get(const ShapedType &type, Arg &&arg) {
+  static DenseIntElementsAttr get(const RankedShapedType &type, Arg &&arg) {
     return DenseElementsAttr::get(type, llvm::ArrayRef(arg))
         .template cast<DenseIntElementsAttr>();
   }
   template <typename T>
-  static DenseIntElementsAttr get(const ShapedType &type,
+  static DenseIntElementsAttr get(const RankedShapedType &type,
                                   const std::initializer_list<T> &list) {
     return DenseElementsAttr::get(type, list)
         .template cast<DenseIntElementsAttr>();
   }
 
   /// Generates a new DenseElementsAttr by mapping each value attribute, and
   /// constructing the DenseElementsAttr given the new element type.
   DenseElementsAttr mapValues(Type newElementType,

 } // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // Attribute Utilities
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 
-/// Given a list of strides (in which ShapedType::kDynamic
+/// Given a list of strides (in which RankedShapedType::kDynamic
 /// represents a dynamic value), return the single result AffineMap which
 /// represents the linearized strided layout map. Dimensions correspond to the
 /// offset followed by the strides in order. Symbols are inserted for each
 /// dynamic dimension in order. A stride is always positive.
 ///
 /// Examples:
 /// =========
 ///

mlir/include/mlir/IR/BuiltinAttributes.td

let description = [{
     Examples:
 
     ```
     // A splat tensor of integer values.
     dense<10> : tensor<2xi32>
     // A tensor of 2 float32 elements.
     dense<[10.0, 11.0]> : tensor<2xf32>
     ```
   }];
-  let parameters = (ins AttributeSelfTypeParameter<"", "ShapedType">:$type,
-                        "ArrayRef<char>":$rawData);
+  let parameters = (ins
+    AttributeSelfTypeParameter<"", "RankedShapedType">:$type,
+    "ArrayRef<char>":$rawData
+  );
   let extraClassDeclaration = [{
     using DenseElementsAttr::empty;
     using DenseElementsAttr::getNumElements;
     using DenseElementsAttr::getElementType;
     using DenseElementsAttr::getValues;
     using DenseElementsAttr::isSplat;
     using DenseElementsAttr::size;
     using DenseElementsAttr::value_begin;
let extraClassDeclaration = [{
 
     /// Convert endianess of input ArrayRef for big-endian(BE) machines. All of
     /// the elements of `inRawData` has `type`. If `inRawData` is little endian
     /// (LE), it is converted to big endian (BE). Conversely, if `inRawData` is
     /// BE, converted to LE.
     static void
     convertEndianOfArrayRefForBEmachine(ArrayRef<char> inRawData,
                                         MutableArrayRef<char> outRawData,
-                                        ShapedType type);
+                                        RankedShapedType type);
 
     /// Convert endianess of input for big-endian(BE) machines. The number of
     /// elements of `inRawData` is `numElements`, and each element has
     /// `elementBitWidth` bits. If `inRawData` is little endian (LE), it is
     /// converted to big endian (BE) and saved in `outRawData`. Conversely, if
     /// `inRawData` is BE, converted to LE.
     static void convertEndianOfCharForBEmachine(const char *inRawData,
                                                 char *outRawData,
                                                 size_t elementBitWidth,
                                                 size_t numElements);
 
   protected:
     friend DenseElementsAttr;
 
     /// Constructs a dense elements attribute from an array of raw APFloat
     /// values. Each APFloat value is expected to have the same bitwidth as the
     /// element type of 'type'. 'type' must be a vector or tensor with static
     /// shape.
     ///
     /// If the `values` array only has a single element, then this constructs
     /// splat of that value.
-    static DenseElementsAttr getRaw(ShapedType type, size_t storageWidth,
+    static DenseElementsAttr getRaw(RankedShapedType type, size_t storageWidth,
                                     ArrayRef<APFloat> values);
 
     /// Constructs a dense elements attribute from an array of raw APInt values.
     /// Each APInt value is expected to have the same bitwidth as the element
     /// type of 'type'. 'type' must be a vector or tensor with static shape.
     ///
     /// If the `values` array only has a single element, then this constructs
     /// splat of that value.
-    static DenseElementsAttr getRaw(ShapedType type, size_t storageWidth,
+    static DenseElementsAttr getRaw(RankedShapedType type, size_t storageWidth,
                                     ArrayRef<APInt> values);
 
     /// Get or create a new dense elements attribute instance with the given raw
     /// data buffer. 'type' must be a vector or tensor with static shape.
     ///
     /// If the `values` array only has a single element, then this constructs
     /// splat of that value.
-    static DenseElementsAttr getRaw(ShapedType type, ArrayRef<char> data);
+    static DenseElementsAttr getRaw(RankedShapedType type, ArrayRef<char> data);
 
     /// Overload of the raw 'get' method that asserts that the given type is of
     /// complex type. This method is used to verify type invariants that the
     /// templatized 'get' method cannot.
-    static DenseElementsAttr getRawComplex(ShapedType type, ArrayRef<char> data,
+    static DenseElementsAttr getRawComplex(RankedShapedType type, ArrayRef<char> data,
                                            int64_t dataEltSize, bool isInt,
                                            bool isSigned);
 
     /// Overload of the raw 'get' method that asserts that the given type is of
     /// integer or floating-point type. This method is used to verify type
     /// invariants that the templatized 'get' method cannot.
-    static DenseElementsAttr getRawIntOrFloat(ShapedType type,
+    static DenseElementsAttr getRawIntOrFloat(RankedShapedType type,
                                               ArrayRef<char> data,
                                               int64_t dataEltSize, bool isInt,
                                               bool isSigned);
   public:
   }];
   let genAccessors = 0;
   let genStorageClass = 0;
   let skipDefaultBuilders = 1;
let description = [{
     Examples:
 
     ```
     // A splat tensor of strings.
     dense<"example"> : tensor<2x!foo.string>
     // A tensor of 2 string elements.
     dense<["example1", "example2"]> : tensor<2x!foo.string>
     ```
   }];
-  let parameters = (ins AttributeSelfTypeParameter<"", "ShapedType">:$type,
-                        "ArrayRef<StringRef>":$value);
+  let parameters = (ins
+    AttributeSelfTypeParameter<"", "RankedShapedType">:$type,
+    "ArrayRef<StringRef>":$value
+  );
   let builders = [
-    AttrBuilderWithInferredContext<(ins "ShapedType":$type,
+    AttrBuilderWithInferredContext<(ins "RankedShapedType":$type,
                                         "ArrayRef<StringRef>":$values), [{
       return $_get(type.getContext(), type, values,
                    /* isSplat */(values.size() == 1));
     }]>,
   ];
   let extraClassDeclaration = [{
     using DenseElementsAttr::empty;
     using DenseElementsAttr::getNumElements;
let description = [{
 
     ```mlir
     // A tensor referencing a builtin dialect resource, `resource_1`, with two
     // unsigned i32 elements.
     dense_resource<resource_1> : tensor<2xui32>
     ```
   }];
   let parameters = (ins
-    AttributeSelfTypeParameter<"", "ShapedType">:$type,
+    AttributeSelfTypeParameter<"", "RankedShapedType">:$type,
     ResourceHandleParameter<"DenseResourceElementsHandle">:$rawHandle
   );
   let builders = [
     AttrBuilderWithInferredContext<(ins
-      "ShapedType":$type, "DenseResourceElementsHandle":$handle
+      "RankedShapedType":$type, "DenseResourceElementsHandle":$handle
     )>
   ];
   let extraClassDeclaration = [{
   protected:
     /// A builder that inserts a new resource into the builtin dialect's blob
     /// manager using the provided blob. The handle of the inserted blob is used
     /// when building the attribute. The provided `blobName` is used as a hint
     /// for the key of the new handle for the `blob` resource, but may be
     /// changed if necessary to ensure uniqueness during insertion.
     static DenseResourceElementsAttr get(
-      ShapedType type, StringRef blobName, AsmResourceBlob blob
+      RankedShapedType type, StringRef blobName, AsmResourceBlob blob
     );
 
   public:
   }];
   let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
let description = [{
     sparse<[[0, 0], [1, 2]], [1, 5]> : tensor<3x4xi32>
 
     // This represents the following tensor:
     ///  [[1, 0, 0, 0],
     ///   [0, 0, 5, 0],
     ///   [0, 0, 0, 0]]
     ```
   }];
 
-  let parameters = (ins AttributeSelfTypeParameter<"", "ShapedType">:$type,
-                        "DenseIntElementsAttr":$indices,
-                        "DenseElementsAttr":$values);
+  let parameters = (ins
+    AttributeSelfTypeParameter<"", "RankedShapedType">:$type,
+    "DenseElementsAttr":$values
+  );
   let builders = [
-    AttrBuilderWithInferredContext<(ins "ShapedType":$type,
+    AttrBuilderWithInferredContext<(ins "RankedShapedType":$type,
                                         "DenseElementsAttr":$indices,
                                         "DenseElementsAttr":$values), [{
       assert(indices.getType().getElementType().isInteger(64) &&
              "expected sparse indices to be 64-bit integer values");
       assert((type.isa<RankedTensorType, VectorType>()) &&
              "type must be ranked tensor or vector");
       assert(type.hasStaticShape() && "type must have static shape");
       return $_get(type.getContext(), type,
let description = [{
     example, a `MxN` row-major contiguous shaped type would have the strides
     `[N, 1]`. The layout attribute also contains the _offset_ from the base
     pointer of the shaped type to the first effectively accessed element,
     expressed in terms of the number of contiguously stored elements.
 
     Strides must be positive and the offset must be non-negative. Both the
     strides and the offset may be _dynamic_, i.e. their value may not be known
     at compile time. This is expressed as a `?` in the assembly syntax and as
-    `ShapedType::kDynamic` in the code. Stride and offset values
+    `RankedShapedType::kDynamic` in the code. Stride and offset values
     must satisfy the constraints above at runtime, the behavior is undefined
     otherwise.
 
     See [Dialects/Builtin.md#memreftype](MemRef type) for more information.
   }];
 
   let parameters = (ins
     "int64_t":$offset,

mlir/include/mlir/IR/BuiltinTypeInterfaces.td

 
 //===----------------------------------------------------------------------===//
 // ShapedType
 //===----------------------------------------------------------------------===//
 
 def ShapedTypeInterface : TypeInterface<"ShapedType"> {
   let cppNamespace = "::mlir";
   let description = [{
-    This interface provides a common API for interacting with multi-dimensional
-    container types. These types contain a shape and an element type.
+    This interface provides a common API for interacting with ranked or unranked
+    container types. These types have an element type and may have a shape.
 
-    A shape is a list of sizes corresponding to the dimensions of the container.
-    If the number of dimensions in the shape is unknown, the shape is "unranked".
-    If the number of dimensions is known, the shape "ranked". The sizes of the
-    dimensions of the shape must be positive, or kDynamic (in which case the
-    size of the dimension is dynamic, or not statically known).
+    If the number of dimensions in the shape is unknown, the shape is
+    "unranked". If the number of dimensions is known, the shape "ranked". Ranked
+    types should implement `RankedShapedType`, a sub-interface of `ShapedType`.
   }];
   let methods = [
     InterfaceMethod<[{
       Returns a clone of this type with the given shape and element
       type. If a shape is not provided, the current shape of the type is used.
     }],
     "::mlir::ShapedType", "cloneWith", (ins
       "::std::optional<::llvm::ArrayRef<int64_t>>":$shape,
       "::mlir::Type":$elementType
     )>,
 
     InterfaceMethod<[{
       Returns the element type of this shaped type.
     }],
     "::mlir::Type", "getElementType">,
+  ];
+  let extraSharedClassDeclaration = [{
+    /// Return a clone of this type with the given new shape and element type.
+    auto clone(::llvm::ArrayRef<int64_t> shape, Type elementType) {
+      return $_type.cloneWith(shape, elementType);
+    }
+    /// Return a clone of this type with the given new shape.
+    auto clone(::llvm::ArrayRef<int64_t> shape) {
+      return $_type.cloneWith(shape, $_type.getElementType());
+    }
+    /// Return a clone of this type with the given new element type.
+    auto clone(::mlir::Type elementType) {
+      return $_type.cloneWith(/*shape=*/std::nullopt, elementType);
+    }
 
-    InterfaceMethod<[{
-      Returns if this type is ranked, i.e. it has a known number of dimensions.
-    }],
-    "bool", "hasRank">,
+    /// If an element type is an integer or a float, return its width.
+    /// Otherwise, abort.
+    unsigned getElementTypeBitWidth() const {
+      return $_type.getElementType().getIntOrFloatBitWidth();
+    }
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// RankedShapedType
+//===----------------------------------------------------------------------===//
 
+def RankedShapedTypeInterface
+    : TypeInterface<"RankedShapedType", [ShapedTypeInterface]> {
+  let cppNamespace = "::mlir";
+  let description = [{
+    This interface provides a common API for interacting with multi-dimensional
+    container types that have a known rank. These types contain a shape and an
+    element type.
+
+    A shape is a list of sizes corresponding to the dimensions of the container.
+    The sizes of the dimensions of the shape must be positive, or kDynamic (in
+    which case the size of the dimension is dynamic).
+  }];
+  let methods = [
     InterfaceMethod<[{
-      Returns the shape of this type if it is ranked, otherwise asserts.
-    }],
-    "::llvm::ArrayRef<int64_t>", "getShape">,
+      Returns the shape of this type.
+    }], "::llvm::ArrayRef<int64_t>", "getShape">,
   ];
 
   let extraClassDeclaration = [{
     static constexpr int64_t kDynamic =
         std::numeric_limits<int64_t>::min();
 
-    /// Whether the given dimension size indicates a dynamic dimension.
+    /// Return "true" if the given dimension size indicates a dynamic dimension.
     static constexpr bool isDynamic(int64_t dValue) {
-  return dValue == kDynamic;
+      return dValue == kDynamic;
     }
 
-    /// Whether the given shape has any size that indicates a dynamic dimension.
+    /// Return "true" if the given shape has any size that indicates a dynamic
+    /// dimension.
     static bool isDynamicShape(ArrayRef<int64_t> dSizes) {
       return any_of(dSizes, [](int64_t dSize) { return isDynamic(dSize); });
     }
 
-    /// Return the number of elements present in the given shape.
+    /// Return the number of elements present in the given shape. Asserts that
+    /// all dimensions are static.
     static int64_t getNumElements(ArrayRef<int64_t> shape);
   }];
 
   let extraSharedClassDeclaration = [{
-    /// Return a clone of this type with the given new shape and element type.
-    auto clone(::llvm::ArrayRef<int64_t> shape, Type elementType) {
-      return $_type.cloneWith(shape, elementType);
-    }
-    /// Return a clone of this type with the given new shape.
-    auto clone(::llvm::ArrayRef<int64_t> shape) {
-      return $_type.cloneWith(shape, $_type.getElementType());
-    }
-    /// Return a clone of this type with the given new element type.
-    auto clone(::mlir::Type elementType) {
-      return $_type.cloneWith(/*shape=*/std::nullopt, elementType);
-    }
-
-    /// If an element type is an integer or a float, return its width. Otherwise,
-    /// abort.
-    unsigned getElementTypeBitWidth() const {
-      return $_type.getElementType().getIntOrFloatBitWidth();
-    }
-
-    /// If this is a ranked type, return the rank. Otherwise, abort.
+    /// Return the rank of this type.
     int64_t getRank() const {
-      assert($_type.hasRank() && "cannot query rank of unranked shaped type");
       return $_type.getShape().size();
     }
 
     /// If it has static shape, return the number of elements. Otherwise, abort.
     int64_t getNumElements() const {
-      assert(hasStaticShape() && "cannot get element count of dynamic shaped type");
-      return ::mlir::ShapedType::getNumElements($_type.getShape());
+      assert(hasStaticShape()
+             && "cannot get element count of dynamically shaped type");
+      return ::mlir::RankedShapedType::getNumElements($_type.getShape());
     }
 
-    /// Returns true if this dimension has a dynamic size (for ranked types);
-    /// aborts for unranked types.
+    /// Return "true" if this dimension has a dynamic size.
     bool isDynamicDim(unsigned idx) const {
       assert(idx < getRank() && "invalid index for shaped type");
-      return ::mlir::ShapedType::isDynamic($_type.getShape()[idx]);
+      return ::mlir::RankedShapedType::isDynamic($_type.getShape()[idx]);
     }
 
-    /// Returns if this type has a static shape, i.e. if the type is ranked and
-    /// all dimensions have known size (>= 0).
+    /// Return "true" if this type has a static shape, i.e., if all dimensions
+    /// have known size (>= 0).
     bool hasStaticShape() const {
-      return $_type.hasRank() &&
-             !::mlir::ShapedType::isDynamicShape($_type.getShape());
+      return !::mlir::RankedShapedType::isDynamicShape($_type.getShape());
     }
 
-    /// Returns if this type has a static shape and the shape is equal to
-    /// `shape` return true.
+    /// Return "true" if this type has a static shape and the shape is equal to
+    /// `shape`.
     bool hasStaticShape(::llvm::ArrayRef<int64_t> shape) const {
       return hasStaticShape() && $_type.getShape() == shape;
     }
 
-    /// If this is a ranked type, return the number of dimensions with dynamic
-    /// size. Otherwise, abort.
+    /// Return the number of dimensions with dynamic size.
     int64_t getNumDynamicDims() const {
-      return llvm::count_if($_type.getShape(), ::mlir::ShapedType::isDynamic);
+      return llvm::count_if($_type.getShape(), ::mlir::RankedShapedType::isDynamic);
     }
 
-    /// If this is ranked type, return the size of the specified dimension.
-    /// Otherwise, abort.
+    /// Return the size of the specified dimension.
     int64_t getDimSize(unsigned idx) const {
       assert(idx < getRank() && "invalid index for shaped type");
       return $_type.getShape()[idx];
     }
 
-    /// Returns the position of the dynamic dimension relative to just the dynamic
-    /// dimensions, given its `index` within the shape.
+    /// Return the position of the dynamic dimension relative to just the
+    /// dynamic dimensions, given its `index` within the shape.
     unsigned getDynamicDimIndex(unsigned index) const {
       assert(index < getRank() && "invalid index");
-      assert(::mlir::ShapedType::isDynamic(getDimSize(index)) && "invalid index");
+      assert(::mlir::RankedShapedType::isDynamic(getDimSize(index))
+             && "invalid index");
       return llvm::count_if($_type.getShape().take_front(index),
-                            ::mlir::ShapedType::isDynamic);
+                            ::mlir::RankedShapedType::isDynamic);
     }
   }];
 }
 
 #endif // MLIR_IR_BUILTINTYPEINTERFACES_TD_

mlir/include/mlir/IR/BuiltinTypes.h

public:
   using Type::Type;
 
   /// Returns the element type of this tensor type.
   Type getElementType() const;
 
   /// Returns if this type is ranked, i.e. it has a known number of dimensions.
   bool hasRank() const;
 
-  /// Returns the shape of this tensor type.
-  ArrayRef<int64_t> getShape() const;
-
   /// Clone this type with the given shape and element type. If the
   /// provided shape is `None`, the current shape of the type is used.
   TensorType cloneWith(std::optional<ArrayRef<int64_t>> shape,
                        Type elementType) const;
 
   /// Return true if the specified element type is ok in a tensor.
   static bool isValidElementType(Type type);
 
public:
   using Type::Type;
 
   /// Returns the element type of this memref type.
   Type getElementType() const;
 
   /// Returns if this type is ranked, i.e. it has a known number of dimensions.
   bool hasRank() const;
 
-  /// Returns the shape of this memref type.
-  ArrayRef<int64_t> getShape() const;
-
   /// Clone this type with the given shape and element type. If the
   /// provided shape is `None`, the current shape of the type is used.
   BaseMemRefType cloneWith(std::optional<ArrayRef<int64_t>> shape,
                            Type elementType) const;
 
   /// Return true if the specified element type is ok in a memref.
   static bool isValidElementType(Type type);
 

mlir/include/mlir/IR/BuiltinTypes.td

let extraClassDeclaration = [{
     static constexpr unsigned kMaxWidth = (1 << 24) - 1;
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // MemRefType
 //===----------------------------------------------------------------------===//
 
-def Builtin_MemRef : Builtin_Type<"MemRef", [
-    ShapedTypeInterface
-  ], "BaseMemRefType"> {
+def Builtin_MemRef
+    : Builtin_Type<"MemRef", [RankedShapedTypeInterface], "BaseMemRefType"> {
   let summary = "Shaped reference to a region of memory";
   let description = [{
     Syntax:
 
     ```
     memref-type ::= `memref` `<` dimension-list-ranked type
                     (`,` layout-specification)? (`,` memory-space)? `>`
     layout-specification ::= attribute-value
     memory-space ::= attribute-value
TypeBuilderWithInferredContext<(ins
       CArg<"Attribute", "{}">:$memorySpace)>,
     /// [deprecated] `Attribute`-based form should be used instead.
     TypeBuilderWithInferredContext<(ins
       "ArrayRef<int64_t>":$shape, "Type":$elementType,
       "AffineMap":$map,
       "unsigned":$memorySpaceInd)>
   ];
   let extraClassDeclaration = [{
-    using ShapedType::Trait<MemRefType>::clone;
-    using ShapedType::Trait<MemRefType>::getElementTypeBitWidth;
-    using ShapedType::Trait<MemRefType>::getRank;
-    using ShapedType::Trait<MemRefType>::getNumElements;
-    using ShapedType::Trait<MemRefType>::isDynamicDim;
-    using ShapedType::Trait<MemRefType>::hasStaticShape;
-    using ShapedType::Trait<MemRefType>::getNumDynamicDims;
-    using ShapedType::Trait<MemRefType>::getDimSize;
-    using ShapedType::Trait<MemRefType>::getDynamicDimIndex;
+    using ShapedType::Trait<BaseMemRefType>::clone;
+    using ShapedType::Trait<BaseMemRefType>::getElementTypeBitWidth;
+    using RankedShapedType::Trait<MemRefType>::getRank;
+    using RankedShapedType::Trait<MemRefType>::getNumElements;
+    using RankedShapedType::Trait<MemRefType>::isDynamicDim;
+    using RankedShapedType::Trait<MemRefType>::hasStaticShape;
+    using RankedShapedType::Trait<MemRefType>::getNumDynamicDims;
+    using RankedShapedType::Trait<MemRefType>::getDimSize;
+    using RankedShapedType::Trait<MemRefType>::getDynamicDimIndex;
 
     /// This is a builder type that keeps local references to arguments.
     /// Arguments that are passed into the builder must outlive the builder.
     class Builder;
 
     /// [deprecated] Returns the memory space in old raw integer representation.
     /// New `Attribute getMemorySpace()` method should be used instead.
     unsigned getMemorySpaceAsInt() const;
def Builtin_Opaque : Builtin_Type<"Opaque"> {
   let skipDefaultBuilders = 1;
   let genVerifyDecl = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // RankedTensorType
 //===----------------------------------------------------------------------===//
 
-def Builtin_RankedTensor : Builtin_Type<"RankedTensor", [
-    ShapedTypeInterface
-  ], "TensorType"> {
+def Builtin_RankedTensor
+    : Builtin_Type<"RankedTensor", [RankedShapedTypeInterface], "TensorType"> {
   let summary = "Multi-dimensional array with a fixed number of dimensions";
   let description = [{
     Syntax:
 
     ```
     tensor-type ::= `tensor` `<` dimension-list type (`,` encoding)? `>`
     dimension-list ::= (dimension `x`)*
     dimension ::= `?` | decimal-literal
TypeBuilderWithInferredContext<(ins
       "ArrayRef<int64_t>":$shape,
       "Type":$elementType,
       CArg<"Attribute", "{}">:$encoding
     ), [{
       return $_get(elementType.getContext(), shape, elementType, encoding);
     }]>
   ];
   let extraClassDeclaration = [{
-    using ShapedType::Trait<RankedTensorType>::clone;
-    using ShapedType::Trait<RankedTensorType>::getElementTypeBitWidth;
-    using ShapedType::Trait<RankedTensorType>::getRank;
-    using ShapedType::Trait<RankedTensorType>::getNumElements;
-    using ShapedType::Trait<RankedTensorType>::isDynamicDim;
-    using ShapedType::Trait<RankedTensorType>::hasStaticShape;
-    using ShapedType::Trait<RankedTensorType>::getNumDynamicDims;
-    using ShapedType::Trait<RankedTensorType>::getDimSize;
-    using ShapedType::Trait<RankedTensorType>::getDynamicDimIndex;
+    using ShapedType::Trait<TensorType>::clone;
+    using ShapedType::Trait<TensorType>::getElementTypeBitWidth;
+    using RankedShapedType::Trait<RankedTensorType>::getRank;
+    using RankedShapedType::Trait<RankedTensorType>::getNumElements;
+    using RankedShapedType::Trait<RankedTensorType>::isDynamicDim;
+    using RankedShapedType::Trait<RankedTensorType>::hasStaticShape;
+    using RankedShapedType::Trait<RankedTensorType>::getNumDynamicDims;
+    using RankedShapedType::Trait<RankedTensorType>::getDimSize;
+    using RankedShapedType::Trait<RankedTensorType>::getDynamicDimIndex;
 
     /// This is a builder type that keeps local references to arguments.
     /// Arguments that are passed into the builder must outlive the builder.
     class Builder;
   }];
   let skipDefaultBuilders = 1;
   let genVerifyDecl = 1;
 }
let extraClassDeclaration = [{
     }
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // UnrankedMemRefType
 //===----------------------------------------------------------------------===//
 
-def Builtin_UnrankedMemRef : Builtin_Type<"UnrankedMemRef", [
-    ShapedTypeInterface
-  ], "BaseMemRefType"> {
+def Builtin_UnrankedMemRef
+    : Builtin_Type<"UnrankedMemRef", [ShapedTypeInterface], "BaseMemRefType"> {
   let summary = "Shaped reference, with unknown rank, to a region of memory";
   let description = [{
     Syntax:
 
     ```
     unranked-memref-type ::= `memref` `<*x` type (`,` memory-space)? `>`
     memory-space ::= attribute-value
     ```
TypeBuilderWithInferredContext<(ins "Type":$elementType,
       Attribute memorySpaceAttr =
           wrapIntegerMemorySpace(memorySpace, elementType.getContext());
       return UnrankedMemRefType::get(elementType, memorySpaceAttr);
     }]>
   ];
   let extraClassDeclaration = [{
     using ShapedType::Trait<UnrankedMemRefType>::clone;
     using ShapedType::Trait<UnrankedMemRefType>::getElementTypeBitWidth;
-    using ShapedType::Trait<UnrankedMemRefType>::getRank;
-    using ShapedType::Trait<UnrankedMemRefType>::getNumElements;
-    using ShapedType::Trait<UnrankedMemRefType>::isDynamicDim;
-    using ShapedType::Trait<UnrankedMemRefType>::hasStaticShape;
-    using ShapedType::Trait<UnrankedMemRefType>::getNumDynamicDims;
-    using ShapedType::Trait<UnrankedMemRefType>::getDimSize;
-    using ShapedType::Trait<UnrankedMemRefType>::getDynamicDimIndex;
-
-    ArrayRef<int64_t> getShape() const { return std::nullopt; }
 
     /// [deprecated] Returns the memory space in old raw integer representation.
     /// New `Attribute getMemorySpace()` method should be used instead.
     unsigned getMemorySpaceAsInt() const;
   }];
   let skipDefaultBuilders = 1;
   let genVerifyDecl = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // UnrankedTensorType
 //===----------------------------------------------------------------------===//
 
-def Builtin_UnrankedTensor : Builtin_Type<"UnrankedTensor", [
-    ShapedTypeInterface
-  ], "TensorType"> {
+def Builtin_UnrankedTensor
+    : Builtin_Type<"UnrankedTensor", [ShapedTypeInterface], "TensorType"> {
   let summary = "Multi-dimensional array with unknown dimensions";
   let description = [{
     Syntax:
 
     ```
     tensor-type ::= `tensor` `<` `*` `x` type `>`
     ```
 
def Builtin_UnrankedTensor
   let builders = [
     TypeBuilderWithInferredContext<(ins "Type":$elementType), [{
       return $_get(elementType.getContext(), elementType);
     }]>
   ];
   let extraClassDeclaration = [{
     using ShapedType::Trait<UnrankedTensorType>::clone;
     using ShapedType::Trait<UnrankedTensorType>::getElementTypeBitWidth;
-    using ShapedType::Trait<UnrankedTensorType>::getRank;
-    using ShapedType::Trait<UnrankedTensorType>::getNumElements;
-    using ShapedType::Trait<UnrankedTensorType>::isDynamicDim;
-    using ShapedType::Trait<UnrankedTensorType>::hasStaticShape;
-    using ShapedType::Trait<UnrankedTensorType>::getNumDynamicDims;
-    using ShapedType::Trait<UnrankedTensorType>::getDimSize;
-    using ShapedType::Trait<UnrankedTensorType>::getDynamicDimIndex;
-
-    ArrayRef<int64_t> getShape() const { return std::nullopt; }
   }];
   let skipDefaultBuilders = 1;
   let genVerifyDecl = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // VectorType
 //===----------------------------------------------------------------------===//
 
-def Builtin_Vector : Builtin_Type<"Vector", [ShapedTypeInterface], "Type"> {
+def Builtin_Vector
+    : Builtin_Type<"Vector", [RankedShapedTypeInterface], "Type"> {
   let summary = "Multi-dimensional SIMD vector type";
   let description = [{
     Syntax:
 
     ```
     vector-type ::= `vector` `<` vector-dim-list vector-element-type `>`
     vector-element-type ::= float-type | integer-type | index-type
     vector-dim-list := (static-dim-list `x`)? (`[` static-dim-list `]` `x`)?

mlir/include/mlir/IR/OpBase.td

 def IsBaseMemRefTypePred
         : CPred<"$_self.isa<::mlir::BaseMemRefType>()">;
 
 // Whether a type is a ShapedType.
 def IsShapedTypePred : CPred<"$_self.isa<::mlir::ShapedType>()">;
 
 // For a ShapedType, verify that it has a static shape.
 def HasStaticShapePred :
-        CPred<"$_self.cast<::mlir::ShapedType>().hasStaticShape()">;
+    And<[CPred<"$_self.isa<::mlir::RankedShapedType>()">,
+         CPred<"$_self.cast<::mlir::RankedShapedType>().hasStaticShape()">]>;
 
 // Whether a type is a TupleType.
 def IsTupleTypePred : CPred<"$_self.isa<::mlir::TupleType>()">;
 
 //===----------------------------------------------------------------------===//
 // Type definitions
 //===----------------------------------------------------------------------===//
 
class ShapedContainerType<list<Type> allowedTypes,
     Type<And<[containerPred,
               Concat<"[](::mlir::Type elementType) { return ",
                 SubstLeaves<"$_self", "elementType",
                 AnyTypeOf<allowedTypes>.predicate>,
                 "; }($_self.cast<::mlir::ShapedType>().getElementType())">]>,
          descr # " of " # AnyTypeOf<allowedTypes>.summary # " values", cppClassName>;
 
 // Whether a shaped type is ranked.
-def HasRankPred : CPred<"$_self.cast<::mlir::ShapedType>().hasRank()">;
+def HasRankPred : CPred<"$_self.isa<::mlir::RankedShapedType>()">;
 
 // Whether a shaped type has one of the specified ranks.
 class HasAnyRankOfPred<list<int> ranks> : And<[
     HasRankPred,
     Or<!foreach(rank, ranks,
-                CPred<[{$_self.cast<::mlir::ShapedType>().getRank()
+                CPred<[{$_self.cast<::mlir::RankedShapedType>().getRank()
                          == }]
                       # rank>)>]>;
 
 // Whether a shaped type has a rank greater than or equal of the specified rank.
 class HasRankGreaterOrEqualPred<int rank> : And<[
     HasRankPred,
-    CPred<[{$_self.cast<::mlir::ShapedType>().getRank() >= }] # rank>
+    CPred<[{$_self.cast<::mlir::RankedShapedType>().getRank() >= }] # rank>
 ]>;
 
 // Vector types.
 
 class VectorOf<list<Type> allowedTypes> :
   ShapedContainerType<allowedTypes, IsVectorTypePred, "vector",
                       "::mlir::VectorType">;
 

 def F64ElementsAttr : FloatElementsAttr<64>;
 
 // A `width`-bit floating point elements attribute. The attribute should be
 // ranked and has a shape as specified in `dims`.
 class RankedFloatElementsAttr<int width, list<int> dims> : ElementsAttrBase<
   CPred<"$_self.isa<::mlir::DenseFPElementsAttr>() &&"
       "$_self.cast<::mlir::DenseFPElementsAttr>().getType()."
       "getElementType().isF" # width # "() && "
-      // Check that this is ranked and has the specified shape.
-      "$_self.cast<::mlir::DenseFPElementsAttr>().getType().hasRank() && "
+      // Check that this has the specified shape.
       "$_self.cast<::mlir::DenseFPElementsAttr>().getType().getShape() == "
       "::mlir::ArrayRef<int64_t>({" # !interleave(dims, ", ") # "})">,
   width # "-bit float elements attribute of shape [" #
   !interleave(dims, ", ") # "]"> {
 
   let storageType = [{ ::mlir::DenseFPElementsAttr }];
   let returnType = [{ ::mlir::DenseFPElementsAttr }];
 

 // multiple arguments or results. For verifying properties of a single argument
 // or result, prefer operand type constraints.
 
 // These traits often require including "mlir/IR/TypeUtilities.h".
 
 // TODO: Improve the autogenerated error messages.
 
 class Rank<string name> :
-    StrFunc<"$" # name # ".getType().cast<::mlir::ShapedType>().getRank()">;
+    StrFunc<"$" # name # ".getType().cast<::mlir::RankedShapedType>()"
+                                   ".getRank()">;
 
 class Shape<string name> :
-    StrFunc<"$" # name # ".getType().cast<::mlir::ShapedType>().getShape()">;
+    StrFunc<"$" # name # ".getType().cast<::mlir::RankedShapedType>()"
+                                   ".getShape()">;
 
 class ElementCount<string name> :
-  StrFunc<"$" # name # ".getType().cast<::mlir::ShapedType>()"
+  StrFunc<"$" # name # ".getType().cast<::mlir::RankedShapedType>()"
                                  ".getNumElements()">;
 
 class ElementType<string name> : StrFunc<"getElementTypeOrSelf($" # name # ")">;
 
 class AllMatchPred<list<string> values> :
   CPred<!if(!lt(!size(values), 2),
             "true",
             !foldl("(" # !head(values) # ")", !tail(values), acc, v,

mlir/include/mlir/Interfaces/InferTypeOpInterface.h

public:
 
   /// Returns the size of the index'th dimension.
   /// Requires: shape is ranked.
   int64_t getDimSize(int index) const;
 
   /// Returns whether the index'th dimension is dynamic.
   /// Requires: shape is ranked.
   bool isDynamicDim(int index) const {
-    return ShapedType::isDynamic(getDimSize(index));
+    return RankedShapedType::isDynamic(getDimSize(index));
   }
 
   /// Returns whether the shape is fully static.
   bool hasStaticShape() const;
 
   /// Returns the rank of the shape.
   /// Requires: shape is ranked.
   int64_t getRank() const;
class ShapedTypeComponents {
   using ShapeStorageT = SmallVector<int64_t, 3>;
 
 public:
   /// Default construction is an unranked shape.
   ShapedTypeComponents() : elementType(nullptr), attr(nullptr){};
   ShapedTypeComponents(Type elementType)
       : elementType(elementType), attr(nullptr), ranked(false) {}
   ShapedTypeComponents(ShapedType shapedType) : attr(nullptr) {
-    ranked = shapedType.hasRank();
+    ranked = isa<RankedShapedType>(shapedType);
     elementType = shapedType.getElementType();
     if (ranked)
-      dims = llvm::to_vector<4>(shapedType.getShape());
+      dims = llvm::to_vector<4>(cast<RankedShapedType>(shapedType).getShape());
   }
   ShapedTypeComponents(ShapeAdaptor adaptor) : attr(nullptr) {
     ranked = adaptor.hasRank();
     elementType = adaptor.getElementType();
     if (ranked)
       adaptor.getDims(*this);
   }
   template <typename Arg, typename = std::enable_if_t<

mlir/include/mlir/Interfaces/VectorInterfaces.td

InterfaceMethod<
       /*desc=*/"Return the `in_bounds` boolean ArrayAttr.",
       /*retTy=*/"::std::optional<::mlir::ArrayAttr>",
       /*methodName=*/"in_bounds",
       /*args=*/(ins),
       /*methodBody=*/"return $_op.getInBounds();"
       /*defaultImplementation=*/
     >,
     InterfaceMethod<
-      /*desc=*/"Return the ShapedType.",
-      /*retTy=*/"::mlir::ShapedType",
+      /*desc=*/"Return the RankedShapedType.",
+      /*retTy=*/"::mlir::RankedShapedType",
       /*methodName=*/"getShapedType",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/
-        "return $_op.getSource().getType().template cast<::mlir::ShapedType>();"
+        "return $_op.getSource().getType().template cast<::mlir::RankedShapedType>();"
     >,
     InterfaceMethod<
       /*desc=*/"Return the VectorType.",
       /*retTy=*/"::mlir::VectorType",
       /*methodName=*/"getVectorType",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{

mlir/include/mlir/Interfaces/ViewLikeInterface.td

let description = [{
 
     The invariants of this interface are:
       1. `static_offsets`, `static_sizes` and `static_strides` have length
           exactly `getArrayAttrMaxRanks()`[0] (resp. [1], [2]).
       2. `offsets`, `sizes` and `strides` have each length at most
          `getArrayAttrMaxRanks()`[0] (resp. [1], [2]).
       3. if an entry of `static_offsets` (resp. `static_sizes`,
          `static_strides`) is equal to a special sentinel value, namely
-         `ShapedType::kDynamic`, then the corresponding entry is a dynamic
+         `RankedShapedType::kDynamic`, then the corresponding entry is a dynamic
          offset (resp. size, stride).
       4. a variadic `offset` (resp. `sizes`, `strides`) operand  must be present
          for each dynamic offset (resp. size, stride).
       5. `offsets`, `sizes` and `strides` operands are specified in this order
          at operand index starting at `getOffsetSizeAndStrideStartOperandIndex`.
 
     This interface is useful to factor out common behavior and provide support
     for carrying or injecting static behavior through the use of the static
let methods = [
 
     InterfaceMethod<
       /*desc=*/"Return true if the offset `idx` is dynamic.",
       /*retTy=*/"bool",
       /*methodName=*/"isDynamicOffset",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return ::mlir::ShapedType::isDynamic(static_offsets()[idx]);
+        return ::mlir::RankedShapedType::isDynamic(static_offsets()[idx]);
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return true if the size `idx` is dynamic.",
       /*retTy=*/"bool",
       /*methodName=*/"isDynamicSize",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return ::mlir::ShapedType::isDynamic(static_sizes()[idx]);
+        return ::mlir::RankedShapedType::isDynamic(static_sizes()[idx]);
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return true if the stride `idx` is dynamic.",
       /*retTy=*/"bool",
       /*methodName=*/"isDynamicStride",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return ::mlir::ShapedType::isDynamic(static_strides()[idx]);
+        return ::mlir::RankedShapedType::isDynamic(static_strides()[idx]);
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Assert the offset `idx` is a static constant and return its value.
       }],
       /*retTy=*/"int64_t",
       /*methodName=*/"getStaticOffset",
InterfaceMethod<
       /*retTy=*/"unsigned",
       /*methodName=*/"getIndexOfDynamicOffset",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert($_op.isDynamicOffset(idx) && "expected dynamic offset");
         auto numDynamic = getNumDynamicEntriesUpToIdx(
           static_offsets(),
-          ::mlir::ShapedType::isDynamic,
+          ::mlir::RankedShapedType::isDynamic,
           idx);
         return $_op.getOffsetSizeAndStrideStartOperandIndex() + numDynamic;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Assert the size `idx` is dynamic and return the position of the
         corresponding operand.
       }],
       /*retTy=*/"unsigned",
       /*methodName=*/"getIndexOfDynamicSize",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert($_op.isDynamicSize(idx) && "expected dynamic size");
         auto numDynamic = getNumDynamicEntriesUpToIdx(
-          static_sizes(), ::mlir::ShapedType::isDynamic, idx);
+          static_sizes(), ::mlir::RankedShapedType::isDynamic, idx);
         return $_op.getOffsetSizeAndStrideStartOperandIndex() +
           offsets().size() + numDynamic;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Assert the stride `idx` is dynamic and return the position of the
         corresponding operand.
       }],
       /*retTy=*/"unsigned",
       /*methodName=*/"getIndexOfDynamicStride",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert($_op.isDynamicStride(idx) && "expected dynamic stride");
         auto numDynamic = getNumDynamicEntriesUpToIdx(
           static_strides(),
-          ::mlir::ShapedType::isDynamic,
+          ::mlir::RankedShapedType::isDynamic,
           idx);
         return $_op.getOffsetSizeAndStrideStartOperandIndex() +
           offsets().size() + sizes().size() + numDynamic;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Helper method to compute the number of dynamic entries of `staticVals`, up to

mlir/lib/AsmParser/AttributeParser.cpp

public:
   TensorLiteralParser(Parser &p) : p(p) {}
 
   /// Parse the elements of a tensor literal. If 'allowHex' is true, the parser
   /// may also parse a tensor literal that is store as a hex string.
   ParseResult parse(bool allowHex);
 
   /// Build a dense attribute instance with the parsed elements and the given
   /// shaped type.
-  DenseElementsAttr getAttr(SMLoc loc, ShapedType type);
+  DenseElementsAttr getAttr(SMLoc loc, RankedShapedType type);
 
   ArrayRef<int64_t> getShape() const { return shape; }
 
 private:
   /// Get the parsed elements for an integer attribute.
   ParseResult getIntAttrElements(SMLoc loc, Type eltTy,
                                  std::vector<APInt> &intValues);
 
   /// Get the parsed elements for a float attribute.
   ParseResult getFloatAttrElements(SMLoc loc, FloatType eltTy,
                                    std::vector<APFloat> &floatValues);
 
   /// Build a Dense String attribute for the given type.
   DenseElementsAttr getStringAttr(SMLoc loc, ShapedType type, Type eltTy);
 
   /// Build a Dense attribute with hex data for the given type.
-  DenseElementsAttr getHexAttr(SMLoc loc, ShapedType type);
+  DenseElementsAttr getHexAttr(SMLoc loc, RankedShapedType type);
 
   /// Parse a single element, returning failure if it isn't a valid element
   /// literal. For example:
   /// parseElement(1) -> Success, 1
   /// parseElement([1]) -> Failure
   ParseResult parseElement();
 
   /// Parse a list of either lists or elements, returning the dimensions of the
ParseResult TensorLiteralParser::parse(bool allowHex) {
   // Otherwise, parse a list or an individual element.
   if (p.getToken().is(Token::l_square))
     return parseList(shape);
   return parseElement();
 }
 
 /// Build a dense attribute instance with the parsed elements and the given
 /// shaped type.
-DenseElementsAttr TensorLiteralParser::getAttr(SMLoc loc, ShapedType type) {
+DenseElementsAttr TensorLiteralParser::getAttr(SMLoc loc,
+                                               RankedShapedType type) {
   Type eltType = type.getElementType();
 
   // Check to see if we parse the literal from a hex string.
   if (hexStorage &&
       (eltType.isIntOrIndexOrFloat() || eltType.isa<ComplexType>()))
     return getHexAttr(loc, type);
 
   // Check that the parsed storage size has the same number of elements to the
for (auto val : storage) {
     stringValues.push_back(val.second.getStringValue());
     stringRefValues.emplace_back(stringValues.back());
   }
 
   return DenseStringElementsAttr::get(type, stringRefValues);
 }
 
 /// Build a Dense attribute with hex data for the given type.
-DenseElementsAttr TensorLiteralParser::getHexAttr(SMLoc loc, ShapedType type) {
+DenseElementsAttr TensorLiteralParser::getHexAttr(SMLoc loc,
+                                                  RankedShapedType type) {
   Type elementType = type.getElementType();
   if (!elementType.isIntOrIndexOrFloat() && !elementType.isa<ComplexType>()) {
     p.emitError(loc)
         << "expected floating-point, integer, or complex element type, got "
         << elementType;
     return nullptr;
   }
 
Attribute Parser::parseDenseResourceElementsAttr(Type attrType) {
   return DenseResourceElementsAttr::get(shapedType, *handle);
 }
 
 /// Shaped type for elements attribute.
 ///
 ///   elements-literal-type ::= vector-type | ranked-tensor-type
 ///
 /// This method also checks the type has static shape.
-ShapedType Parser::parseElementsLiteralType(Type type) {
+RankedShapedType Parser::parseElementsLiteralType(Type type) {
   // If the user didn't provide a type, parse the colon type for the literal.
   if (!type) {
     if (parseToken(Token::colon, "expected ':'"))
       return nullptr;
     if (!(type = parseType()))
       return nullptr;
   }
 
   auto sType = type.dyn_cast<ShapedType>();
   if (!sType) {
     emitError("elements literal must be a shaped type");
     return nullptr;
   }
 
-  if (!sType.hasStaticShape())
+  auto rsType = dyn_cast<RankedShapedType>(sType);
+  if (!rsType || !rsType.hasStaticShape())
     return (emitError("elements literal type must have static shape"), nullptr);
 
   return sType;
 }
 
 /// Parse a sparse elements attribute.
 Attribute Parser::parseSparseElementsAttr(Type attrType) {
   SMLoc loc = getToken().getLoc();
   consumeToken(Token::kw_sparse);
   if (parseToken(Token::less, "Expected '<' after 'sparse'"))
     return nullptr;
 
   // Check for the case where all elements are sparse. The indices are
   // represented by a 2-dimensional shape where the second dimension is the rank
   // of the type.
   Type indiceEltType = builder.getIntegerType(64);
   if (consumeIf(Token::greater)) {
-    ShapedType type = parseElementsLiteralType(attrType);
+    RankedShapedType type = parseElementsLiteralType(attrType);
     if (!type)
       return nullptr;
 
     // Construct the sparse elements attr using zero element indice/value
     // attributes.
     ShapedType indicesType =
         RankedTensorType::get({0, type.getRank()}, indiceEltType);
     ShapedType valuesType = RankedTensorType::get({0}, type.getElementType());
Attribute Parser::parseSparseElementsAttr(Type attrType) {
   if (!type)
     return nullptr;
 
   // If the indices are a splat, i.e. the literal parser parsed an element and
   // not a list, we set the shape explicitly. The indices are represented by a
   // 2-dimensional shape where the second dimension is the rank of the type.
   // Given that the parsed indices is a splat, we know that we only have one
   // indice and thus one for the first dimension.
-  ShapedType indicesType;
+  RankedShapedType indicesType;
   if (indiceParser.getShape().empty()) {
     indicesType = RankedTensorType::get({1, type.getRank()}, indiceEltType);
   } else {
     // Otherwise, set the shape to the one parsed by the literal parser.
     indicesType = RankedTensorType::get(indiceParser.getShape(), indiceEltType);
   }
   auto indices = indiceParser.getAttr(indicesLoc, indicesType);
 
if (failed(parseToken(Token::less, "expected '<' after 'strided'")) ||
       failed(parseToken(Token::l_square, "expected '['")))
     return nullptr;
 
   // Parses either an integer token or a question mark token. Reports an error
   // and returns std::nullopt if the current token is neither. The integer token
   // must fit into int64_t limits.
   auto parseStrideOrOffset = [&]() -> std::optional<int64_t> {
     if (consumeIf(Token::question))
-      return ShapedType::kDynamic;
+      return RankedShapedType::kDynamic;
 
     SMLoc loc = getToken().getLoc();
     auto emitWrongTokenError = [&] {
       emitError(loc, "expected a 64-bit signed integer or '?'");
       return std::nullopt;
     };
 
     bool negative = consumeIf(Token::minus);

mlir/lib/AsmParser/Parser.h

public:
   Attribute parseFloatAttr(Type type, bool isNegative);
 
   /// Parse a decimal or a hexadecimal literal, which can be either an integer
   /// or a float attribute.
   Attribute parseDecOrHexAttr(Type type, bool isNegative);
 
   /// Parse a dense elements attribute.
   Attribute parseDenseElementsAttr(Type attrType);
-  ShapedType parseElementsLiteralType(Type type);
+  RankedShapedType parseElementsLiteralType(Type type);
 
   /// Parse a dense resource elements attribute.
   Attribute parseDenseResourceElementsAttr(Type attrType);
 
   /// Parse a DenseArrayAttr.
   Attribute parseDenseArrayAttr(Type type);
 
   /// Parse a sparse elements attribute.

mlir/lib/AsmParser/TypeParser.cpp

 ParseResult
 Parser::parseDimensionListRanked(SmallVectorImpl<int64_t> &dimensions,
                                  bool allowDynamic, bool withTrailingX) {
   auto parseDim = [&]() -> LogicalResult {
     auto loc = getToken().getLoc();
     if (consumeIf(Token::question)) {
       if (!allowDynamic)
         return emitError(loc, "expected static shape");
-      dimensions.push_back(ShapedType::kDynamic);
+      dimensions.push_back(RankedShapedType::kDynamic);
     } else {
       int64_t value;
       if (failed(parseIntegerInDimensionList(value)))
         return failure();
       dimensions.push_back(value);
     }
     return success();
   };

mlir/lib/CAPI/IR/BuiltinTypes.cpp

 
 bool mlirTypeIsAShaped(MlirType type) { return unwrap(type).isa<ShapedType>(); }
 
 MlirType mlirShapedTypeGetElementType(MlirType type) {
   return wrap(unwrap(type).cast<ShapedType>().getElementType());
 }
 
 bool mlirShapedTypeHasRank(MlirType type) {
-  return unwrap(type).cast<ShapedType>().hasRank();
+  return unwrap(type).isa<RankedShapedType>();
 }
 
 int64_t mlirShapedTypeGetRank(MlirType type) {
-  return unwrap(type).cast<ShapedType>().getRank();
+  return unwrap(type).cast<RankedShapedType>().getRank();
 }
 
 bool mlirShapedTypeHasStaticShape(MlirType type) {
-  return unwrap(type).cast<ShapedType>().hasStaticShape();
+  auto rankedShapedType = unwrap(type).dyn_cast<RankedShapedType>();
+  return rankedShapedType && rankedShapedType.hasStaticShape();
 }
 
 bool mlirShapedTypeIsDynamicDim(MlirType type, intptr_t dim) {
-  return unwrap(type).cast<ShapedType>().isDynamicDim(
+  return unwrap(type).cast<RankedShapedType>().isDynamicDim(
       static_cast<unsigned>(dim));
 }
 
 int64_t mlirShapedTypeGetDimSize(MlirType type, intptr_t dim) {
-  return unwrap(type).cast<ShapedType>().getDimSize(static_cast<unsigned>(dim));
+  return unwrap(type).cast<RankedShapedType>().getDimSize(
+      static_cast<unsigned>(dim));
 }
 
-int64_t mlirShapedTypeGetDynamicSize() { return ShapedType::kDynamic; }
+int64_t mlirShapedTypeGetDynamicSize() { return RankedShapedType::kDynamic; }
 
 bool mlirShapedTypeIsDynamicSize(int64_t size) {
-  return ShapedType::isDynamic(size);
+  return RankedShapedType::isDynamic(size);
 }
 
 bool mlirShapedTypeIsDynamicStrideOrOffset(int64_t val) {
-  return ShapedType::isDynamic(val);
+  return RankedShapedType::isDynamic(val);
 }
 
 int64_t mlirShapedTypeGetDynamicStrideOrOffset() {
-  return ShapedType::kDynamic;
+  return RankedShapedType::kDynamic;
 }
 
 //===----------------------------------------------------------------------===//
 // Vector type.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsAVector(MlirType type) { return unwrap(type).isa<VectorType>(); }
 

mlir/lib/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.cpp

matchAndRewrite(GpuOp gpuOp, typename GpuOp::Adaptor adaptor,
     args.push_back(resource);
 
     // Indexing (voffset)
     Value voffset = createI32Constant(rewriter, loc, 0);
     for (auto pair : llvm::enumerate(adaptor.getIndices())) {
       size_t i = pair.index();
       Value index = pair.value();
       Value strideOp;
-      if (ShapedType::isDynamic(strides[i])) {
+      if (RankedShapedType::isDynamic(strides[i])) {
         strideOp = rewriter.create<LLVM::MulOp>(
             loc, memrefDescriptor.stride(rewriter, loc, i), byteWidthConst);
       } else {
         strideOp =
             createI32Constant(rewriter, loc, strides[i] * elementByteWidth);
       }
       index = rewriter.create<LLVM::MulOp>(loc, index, strideOp);
       voffset = rewriter.create<LLVM::AddOp>(loc, voffset, index);
     }
     if (adaptor.getIndexOffset()) {
       int32_t indexOffset = *gpuOp.getIndexOffset() * elementByteWidth;
       Value extraOffsetConst = createI32Constant(rewriter, loc, indexOffset);
       voffset =
           voffset ? rewriter.create<LLVM::AddOp>(loc, voffset, extraOffsetConst)
                   : extraOffsetConst;
     }
     args.push_back(voffset);
 
     Value sgprOffset = adaptor.getSgprOffset();
     if (!sgprOffset)
       sgprOffset = createI32Constant(rewriter, loc, 0);
-    if (ShapedType::isDynamic(offset))
+    if (RankedShapedType::isDynamic(offset))
       sgprOffset = rewriter.create<LLVM::AddOp>(
           loc, memrefDescriptor.offset(rewriter, loc), sgprOffset);
     else if (offset > 0)
       sgprOffset = rewriter.create<LLVM::AddOp>(
           loc, sgprOffset, createI32Constant(rewriter, loc, offset));
     args.push_back(sgprOffset);
 
     // bit 0: GLC = 0 (atomics drop value, less coherency)

mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp

 
 //===----------------------------------------------------------------------===//
 // ConstantOp with composite type
 //===----------------------------------------------------------------------===//
 
 LogicalResult ConstantCompositeOpPattern::matchAndRewrite(
     arith::ConstantOp constOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
-  auto srcType = constOp.getType().dyn_cast<ShapedType>();
+  auto srcType = constOp.getType().dyn_cast<RankedShapedType>();
   if (!srcType || srcType.getNumElements() == 1)
     return failure();
 
   // arith.constant should only have vector or tenor types.
   assert((srcType.isa<VectorType, RankedTensorType>()));
 
   Type dstType = getTypeConverter()->convertType(srcType);
   if (!dstType)
if (srcElemType.isa<FloatType>()) {
         elements.push_back(dstAttr);
       }
     }
 
     // Unfortunately, we cannot use dialect-specific types for element
     // attributes; element attributes only works with builtin types. So we need
     // to prepare another converted builtin types for the destination elements
     // attribute.
-    if (dstAttrType.isa<RankedTensorType>())
-      dstAttrType = RankedTensorType::get(dstAttrType.getShape(), dstElemType);
-    else
-      dstAttrType = VectorType::get(dstAttrType.getShape(), dstElemType);
+    if (auto rankedTensoType = dstAttrType.dyn_cast<RankedTensorType>()) {
+      dstAttrType =
+          RankedTensorType::get(rankedTensoType.getShape(), dstElemType);
+    } else {
+      dstAttrType = VectorType::get(
+          dstAttrType.cast<RankedShapedType>().getShape(), dstElemType);
+    }
 
     dstElementsAttr = DenseElementsAttr::get(dstAttrType, elements);
   }
 
   rewriter.replaceOpWithNewOp<spirv::ConstantOp>(constOp, dstType,
                                                  dstElementsAttr);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp with scalar type
 //===----------------------------------------------------------------------===//
 
 LogicalResult ConstantScalarOpPattern::matchAndRewrite(
     arith::ConstantOp constOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   Type srcType = constOp.getType();
-  if (auto shapedType = srcType.dyn_cast<ShapedType>()) {
+  if (auto shapedType = srcType.dyn_cast<RankedShapedType>()) {
     if (shapedType.getNumElements() != 1)
       return failure();
     srcType = shapedType.getElementType();
   }
   if (!srcType.isIntOrIndexOrFloat())
     return failure();
 
   Attribute cstAttr = constOp.getValue();

mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp

 
 MemRefDescriptor MemRefDescriptor::fromStaticShape(
     OpBuilder &builder, Location loc, LLVMTypeConverter &typeConverter,
     MemRefType type, Value memory, Value alignedMemory) {
   assert(type.hasStaticShape() && "unexpected dynamic shape");
 
   // Extract all strides and offsets and verify they are static.
   auto [strides, offset] = getStridesAndOffset(type);
-  assert(!ShapedType::isDynamic(offset) &&
-         "expected static offset");
-  assert(!llvm::any_of(strides, ShapedType::isDynamic) &&
+  assert(!RankedShapedType::isDynamic(offset) && "expected static offset");
+  assert(!llvm::any_of(strides, RankedShapedType::isDynamic) &&
          "expected static strides");
 
   auto convertedType = typeConverter.convertType(type);
   assert(convertedType && "unexpected failure in memref type conversion");
 
   auto descr = MemRefDescriptor::undef(builder, loc, convertedType);
   descr.setAllocatedPtr(builder, loc, memory);
   descr.setAlignedPtr(builder, loc, alignedMemory);

mlir/lib/Conversion/LLVMCommon/Pattern.cpp

Value ConvertToLLVMPattern::getStridedElementPtr(
 
   auto [strides, offset] = getStridesAndOffset(type);
 
   MemRefDescriptor memRefDescriptor(memRefDesc);
   Value base = memRefDescriptor.alignedPtr(rewriter, loc);
 
   Value index;
   if (offset != 0) // Skip if offset is zero.
-    index = ShapedType::isDynamic(offset)
+    index = RankedShapedType::isDynamic(offset)
                 ? memRefDescriptor.offset(rewriter, loc)
                 : createIndexConstant(rewriter, loc, offset);
 
   for (int i = 0, e = indices.size(); i < e; ++i) {
     Value increment = indices[i];
     if (strides[i] != 1) { // Skip if stride is 1.
-      Value stride = ShapedType::isDynamic(strides[i])
+      Value stride = RankedShapedType::isDynamic(strides[i])
                          ? memRefDescriptor.stride(rewriter, loc, i)
                          : createIndexConstant(rewriter, loc, strides[i]);
       increment = rewriter.create<LLVM::MulOp>(loc, increment, stride);
     }
     index =
         index ? rewriter.create<LLVM::AddOp>(loc, index, increment) : increment;
   }
 

 }
 
 void ConvertToLLVMPattern::getMemRefDescriptorSizes(
     Location loc, MemRefType memRefType, ValueRange dynamicSizes,
     ConversionPatternRewriter &rewriter, SmallVectorImpl<Value> &sizes,
     SmallVectorImpl<Value> &strides, Value &sizeBytes) const {
   assert(isConvertibleAndHasIdentityMaps(memRefType) &&
          "layout maps must have been normalized away");
-  assert(count(memRefType.getShape(), ShapedType::kDynamic) ==
+  assert(count(memRefType.getShape(), RankedShapedType::kDynamic) ==
              static_cast<ssize_t>(dynamicSizes.size()) &&
          "dynamicSizes size doesn't match dynamic sizes count in memref shape");
 
   sizes.reserve(memRefType.getRank());
   unsigned dynamicIndex = 0;
   for (int64_t size : memRefType.getShape()) {
-    sizes.push_back(size == ShapedType::kDynamic
+    sizes.push_back(size == RankedShapedType::kDynamic
                         ? dynamicSizes[dynamicIndex++]
                         : createIndexConstant(rewriter, loc, size));
   }
 
   // Strides: iterate sizes in reverse order and multiply.
   int64_t stride = 1;
   Value runningStride = createIndexConstant(rewriter, loc, 1);
   strides.resize(memRefType.getRank());
   for (auto i = memRefType.getRank(); i-- > 0;) {
     strides[i] = runningStride;
 
     int64_t size = memRefType.getShape()[i];
     if (size == 0)
       continue;
     bool useSizeAsStride = stride == 1;
-    if (size == ShapedType::kDynamic)
-      stride = ShapedType::kDynamic;
-    if (stride != ShapedType::kDynamic)
+    if (size == RankedShapedType::kDynamic)
+      stride = RankedShapedType::kDynamic;
+    if (stride != RankedShapedType::kDynamic)
       stride *= size;
 
     if (useSizeAsStride)
       runningStride = sizes[i];
-    else if (stride == ShapedType::kDynamic)
+    else if (stride == RankedShapedType::kDynamic)
       runningStride =
           rewriter.create<LLVM::MulOp>(loc, runningStride, sizes[i]);
     else
       runningStride = createIndexConstant(rewriter, loc, stride);
   }
 
   // Buffer size in bytes.
   Type elementType = typeConverter->convertType(memRefType.getElementType());

mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp

if (!memrefTy.hasStaticShape())
     return false;
 
   int64_t offset = 0;
   SmallVector<int64_t, 4> strides;
   if (failed(getStridesAndOffset(memrefTy, strides, offset)))
     return false;
 
   for (int64_t stride : strides)
-    if (ShapedType::isDynamic(stride))
+    if (RankedShapedType::isDynamic(stride))
       return false;
 
-  return !ShapedType::isDynamic(offset);
+  return !RankedShapedType::isDynamic(offset);
 }
 
 /// Convert a memref type to a bare pointer to the memref element type.
 Type LLVMTypeConverter::convertMemRefToBarePtr(BaseMemRefType type) {
   if (!canConvertToBarePtr(type))
     return {};
   Type elementType = convertType(type.getElementType());
   if (!elementType)

mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp

 #include "mlir/Conversion/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 static MemRefType makeStridedLayoutDynamic(MemRefType type) {
   return MemRefType::Builder(type).setLayout(StridedLayoutAttr::get(
-      type.getContext(), ShapedType::kDynamic,
-      SmallVector<int64_t>(type.getRank(), ShapedType::kDynamic)));
+      type.getContext(), RankedShapedType::kDynamic,
+      SmallVector<int64_t>(type.getRank(), RankedShapedType::kDynamic)));
 }
 
 /// Helper function to extract the operand types that are passed to the
 /// generated CallOp. MemRefTypes have their layout canonicalized since the
 /// information is not used in signature generation.
 /// Note that static size information is not modified.
 static SmallVector<Type, 4> extractOperandTypes(Operation *op) {
   SmallVector<Type, 4> result;

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

 #include "mlir/Conversion/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
 
 namespace {
 
 bool isStaticStrideOrOffset(int64_t strideOrOffset) {
-  return !ShapedType::isDynamic(strideOrOffset);
+  return !RankedShapedType::isDynamic(strideOrOffset);
 }
 
 LLVM::LLVMFuncOp getFreeFn(LLVMTypeConverter *typeConverter, ModuleOp module) {
   bool useGenericFn = typeConverter->getOptions().useGenericFunctions;
 
   if (useGenericFn)
     return LLVM::lookupOrCreateGenericFreeFn(
         module, typeConverter->useOpaquePointers());
if (shapeMemRefType.hasStaticShape()) {
       desc.setConstantOffset(rewriter, loc, offset);
 
       assert(targetMemRefType.getLayout().isIdentity() &&
              "Identity layout map is a precondition of a valid reshape op");
 
       Value stride = nullptr;
       int64_t targetRank = targetMemRefType.getRank();
       for (auto i : llvm::reverse(llvm::seq<int64_t>(0, targetRank))) {
-        if (!ShapedType::isDynamic(strides[i])) {
+        if (!RankedShapedType::isDynamic(strides[i])) {
           // If the stride for this dimension is dynamic, then use the product
           // of the sizes of the inner dimensions.
           stride = createIndexConstant(rewriter, loc, strides[i]);
         } else if (!stride) {
           // `stride` is null only in the first iteration of the loop.  However,
           // since the target memref has an identity layout, we can safely set
           // the innermost stride to 1.
           stride = createIndexConstant(rewriter, loc, 1);
struct ViewOpLowering : public ConvertOpToLLVMPattern<memref::ViewOp> {
   using ConvertOpToLLVMPattern<memref::ViewOp>::ConvertOpToLLVMPattern;
 
   // Build and return the value for the idx^th shape dimension, either by
   // returning the constant shape dimension or counting the proper dynamic size.
   Value getSize(ConversionPatternRewriter &rewriter, Location loc,
                 ArrayRef<int64_t> shape, ValueRange dynamicSizes,
                 unsigned idx) const {
     assert(idx < shape.size());
-    if (!ShapedType::isDynamic(shape[idx]))
+    if (!RankedShapedType::isDynamic(shape[idx]))
       return createIndexConstant(rewriter, loc, shape[idx]);
     // Count the number of dynamic dims in range [0, idx]
     unsigned nDynamic =
-        llvm::count_if(shape.take_front(idx), ShapedType::isDynamic);
+        llvm::count_if(shape.take_front(idx), RankedShapedType::isDynamic);
     return dynamicSizes[nDynamic];
   }
 
   // Build and return the idx^th stride, either by returning the constant stride
   // or by computing the dynamic stride from the current `runningStride` and
   // `nextSize`. The caller should keep a running stride and update it with the
   // result returned by this function.
   Value getStride(ConversionPatternRewriter &rewriter, Location loc,
                   ArrayRef<int64_t> strides, Value nextSize,
                   Value runningStride, unsigned idx) const {
     assert(idx < strides.size());
-    if (!ShapedType::isDynamic(strides[idx]))
+    if (!RankedShapedType::isDynamic(strides[idx]))
       return createIndexConstant(rewriter, loc, strides[idx]);
     if (nextSize)
       return runningStride
                  ? rewriter.create<LLVM::MulOp>(loc, runningStride, nextSize)
                  : nextSize;
     assert(!runningStride);
     return createIndexConstant(rewriter, loc, 1);
   }

mlir/lib/Conversion/MemRefToSPIRV/MapMemRefStorageClassPass.cpp

if (!storage) {
                  << "cannot convert " << memRefType
                  << " due to being unable to find memory space in map\n");
       return std::nullopt;
     }
 
     auto storageAttr =
         spirv::StorageClassAttr::get(memRefType.getContext(), *storage);
     if (auto rankedType = memRefType.dyn_cast<MemRefType>()) {
-      return MemRefType::get(memRefType.getShape(), memRefType.getElementType(),
+      return MemRefType::get(rankedType.getShape(), memRefType.getElementType(),
                              rankedType.getLayout(), storageAttr);
     }
     return UnrankedMemRefType::get(memRefType.getElementType(), storageAttr);
   });
 
   addConversion([this](FunctionType type) {
     SmallVector<Type> inputs, results;
     inputs.reserve(type.getNumInputs());

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

 elementwiseMatchAndRewriteHelper(Operation *operation,
                                  PatternRewriter &rewriter) {
   auto loc = operation->getLoc();
 
   assert(operation->getNumResults() == 1 &&
          "All TOSA elementwise ops should only return a single result.");
 
   auto results = operation->getResults();
-  auto resultTy = operation->getResult(0).getType().dyn_cast<ShapedType>();
+  auto resultTy =
+      operation->getResult(0).getType().dyn_cast<RankedShapedType>();
 
   if (!resultTy)
     return rewriter.notifyMatchFailure(operation,
                                        "All results must be a shaped type");
 
   unsigned rank = resultTy.getRank();
 
   // Construct the indexing maps needed for linalg.generic ops.
   SmallVector<Type> bodyArgTypes;
 
   for (Value in : operation->getOperands())
     bodyArgTypes.emplace_back(getElementTypeOrSelf(in.getType()));
 
   SmallVector<Type> opResultTypes;
   SmallVector<Value> emptyTensors;
 
   SmallVector<Value> dynDims;
-  dynDims.resize(results.front().getType().cast<ShapedType>().getRank());
+  dynDims.resize(results.front().getType().cast<RankedShapedType>().getRank());
 
   for (auto arg : operation->getOperands()) {
-    auto operandTy = arg.getType().cast<ShapedType>();
+    auto operandTy = arg.getType().cast<RankedShapedType>();
     for (int i = 0; i < operandTy.getRank(); i++) {
       if (operandTy.isDynamicDim(i) && !dynDims[i])
         dynDims[i] = rewriter.create<tensor::DimOp>(loc, arg, i);
     }
   }
 
   SmallVector<Value> filteredDims = condenseValues(dynDims);
 
   for (auto result : results) {
-    auto resultTy = result.getType().template cast<ShapedType>();
+    auto resultTy = result.getType().template cast<RankedShapedType>();
     emptyTensors.push_back(rewriter.create<tensor::EmptyOp>(
         loc, resultTy.getShape(), resultTy.getElementType(), filteredDims));
     opResultTypes.push_back(result.getType());
   }
 
   auto bodyResultTypes = llvm::to_vector<4>(llvm::map_range(
       emptyTensors, [](Value v) { return getElementTypeOrSelf(v); }));
 
   SmallVector<Value, 2> operands;
   SmallVector<AffineMap, 2> indexingMaps;
   indexingMaps.reserve(operation->getNumOperands() + bodyResultTypes.size());
 
   // Input indexing maps may be broadcasted.
   for (Value operand : operation->getOperands()) {
-    ShapedType type = operand.getType().cast<ShapedType>();
+    auto type = operand.getType().cast<RankedShapedType>();
 
     if (type.getShape() == resultTy.getShape()) {
       operands.push_back(operand);
       indexingMaps.push_back(rewriter.getMultiDimIdentityMap(rank));
       continue;
     }
 
     SmallVector<int64_t, 5> newShape;

 }
 
 // Performs the match and rewrite for reduction operations. This includes
 // declaring a correctly sized initial value, and the linalg.generic operation
 // that reduces across the specified axis.
 static LogicalResult reduceMatchAndRewriteHelper(Operation *op, uint64_t axis,
                                                  PatternRewriter &rewriter) {
   auto loc = op->getLoc();
-  auto inputTy = op->getOperand(0).getType().template cast<ShapedType>();
+  auto inputTy = op->getOperand(0).getType().template cast<RankedShapedType>();
   auto resultTy = op->getResult(0).getType().template cast<ShapedType>();
   auto elementTy = resultTy.getElementType();
   Value input = op->getOperand(0);
 
   llvm::SmallVector<int64_t> reduceShape;
   SmallVector<Value> dynDims;
   for (unsigned i = 0; i < inputTy.getRank(); i++) {
     if (axis != i) {
auto linalgOp = rewriter.create<linalg::GenericOp>(
       });
 
   if (!didEncounterError)
     return rewriter.notifyMatchFailure(
         op, "unable to create linalg.generic body for reduce op");
 
   SmallVector<ReassociationExprs, 4> reassociationMap;
   uint64_t expandInputRank =
-      linalgOp.getResults()[0].getType().cast<ShapedType>().getRank();
+      linalgOp.getResults()[0].getType().cast<RankedShapedType>().getRank();
   reassociationMap.resize(expandInputRank);
 
   for (uint64_t i = 0; i < expandInputRank; i++) {
     int32_t dimToPush = i > axis ? i + 1 : i;
     reassociationMap[i].push_back(rewriter.getAffineDimExpr(dimToPush));
   }
 
   if (expandInputRank != 0) {
LogicalResult matchAndRewrite(tosa::TransposeOp op,
                                 PatternRewriter &rewriter) const final {
     DenseIntElementsAttr perms;
     if (!matchPattern(op.getPerms(), m_Constant(&perms))) {
       return rewriter.notifyMatchFailure(op, "unmatched permutation tensor");
     }
 
     auto loc = op.getLoc();
     auto input = op->getOperand(0);
-    auto resultTy = op.getType().cast<ShapedType>();
+    auto resultTy = op.getType().cast<RankedShapedType>();
 
     SmallVector<Value> dynDims;
-    dynDims.resize(op->getResult(0).getType().cast<ShapedType>().getRank());
+    dynDims.resize(
+        op->getResult(0).getType().cast<RankedShapedType>().getRank());
 
     SmallVector<AffineExpr, 2> inputExprs;
     inputExprs.resize(resultTy.getRank());
-    auto operandTy = input.getType().cast<ShapedType>();
+    auto operandTy = input.getType().dyn_cast<RankedShapedType>();
     for (const auto &permutation : llvm::enumerate(perms.getValues<APInt>())) {
       auto index = permutation.index();
       auto value = permutation.value().getZExtValue();
-      if (!operandTy.hasRank() || operandTy.isDynamicDim(index)) {
+      if (!operandTy || operandTy.isDynamicDim(index)) {
         dynDims[value] = rewriter.create<tensor::DimOp>(loc, input, index);
       }
       inputExprs[value] = rewriter.getAffineDimExpr(index);
     }
 
     SmallVector<Value> filteredDims = condenseValues(dynDims);
 
     auto emptyTensor = rewriter.create<tensor::EmptyOp>(

 class RescaleConverter : public OpRewritePattern<tosa::RescaleOp> {
 public:
   using OpRewritePattern<tosa::RescaleOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::RescaleOp op,
                                 PatternRewriter &rewriter) const final {
     auto loc = op.getLoc();
     auto input = op.getInput();
-    auto inputTy = op.getInput().getType().cast<ShapedType>();
-    auto outputTy = op.getOutput().getType().cast<ShapedType>();
+    auto inputTy = op.getInput().getType().cast<RankedShapedType>();
+    auto outputTy = op.getOutput().getType().cast<RankedShapedType>();
     unsigned rank = inputTy.getRank();
 
     // This is an illegal configuration. terminate and log an error
     if (op.getDoubleRound() && !op.getScale32())
       return rewriter.notifyMatchFailure(
           op, "tosa.rescale requires scale32 for double_round to be true");
 
     SmallVector<Value> dynDims;
LogicalResult matchAndRewrite(tosa::ResizeOp op,
     // Get any dynamic shapes that appear in the input format.
     llvm::SmallVector<Value> outputDynSize;
     if (inputTy.isDynamicDim(0))
       outputDynSize.push_back(builder.create<tensor::DimOp>(input, 0));
     if (inputTy.isDynamicDim(3))
       outputDynSize.push_back(builder.create<tensor::DimOp>(input, 3));
 
     // Generate the elementwise operation for casting scaling the input value.
-    auto genericTy = collapseTy.clone(resultTy.getElementType());
+    auto genericTy =
+        collapseTy.clone(resultTy.getElementType()).cast<RankedTensorType>();
     Value empty = builder.create<tensor::EmptyOp>(
         genericTy.getShape(), resultTy.getElementType(), outputDynSize);
     auto genericMap = rewriter.getMultiDimIdentityMap(genericTy.getRank());
     SmallVector<utils::IteratorType> iterators(genericTy.getRank(),
                                                utils::IteratorType::parallel);
 
     auto generic = builder.create<linalg::GenericOp>(
         genericTy, ValueRange{collapse}, ValueRange{empty},

 public:
   using OpRewritePattern<tosa::ResizeOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::ResizeOp op,
                                 PatternRewriter &rewriter) const final {
     Location loc = op.getLoc();
     ImplicitLocOpBuilder b(loc, rewriter);
     auto input = op.getInput();
-    auto inputTy = input.getType().cast<ShapedType>();
-    auto resultTy = op.getType().cast<ShapedType>();
+    auto inputTy = input.getType().cast<RankedShapedType>();
+    auto resultTy = op.getType().cast<RankedShapedType>();
     auto resultETy = resultTy.getElementType();
 
     auto imageH = inputTy.getShape()[1];
     auto imageW = inputTy.getShape()[2];
 
     auto dynamicDimsOr =
         checkHasDynamicBatchDims(rewriter, op, {input, op.getOutput()});
     if (!dynamicDimsOr.has_value())

 class ReverseConverter : public OpRewritePattern<tosa::ReverseOp> {
 public:
   using OpRewritePattern<tosa::ReverseOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::ReverseOp op,
                                 PatternRewriter &rewriter) const final {
     auto loc = op.getLoc();
     Value input = op.getInput();
-    auto inputTy = input.getType().template cast<ShapedType>();
-    auto resultTy = op.getType().template cast<ShapedType>();
+    auto inputTy = input.getType().template cast<RankedShapedType>();
+    auto resultTy = op.getType().template cast<RankedShapedType>();
     auto axis = op.getAxis();
 
     SmallVector<Value> dynDims;
     for (int i = 0; i < inputTy.getRank(); i++) {
       if (inputTy.isDynamicDim(i)) {
         dynDims.push_back(rewriter.create<tensor::DimOp>(loc, input, i));
       }
     }

 struct TileConverter : public OpConversionPattern<tosa::TileOp> {
   using OpConversionPattern<tosa::TileOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(tosa::TileOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = op.getLoc();
     auto input = op.getInput1();
-    auto inputTy = input.getType().cast<ShapedType>();
+    auto inputTy = input.getType().cast<RankedShapedType>();
     auto inputShape = inputTy.getShape();
-    auto resultTy = op.getType().cast<ShapedType>();
+    auto resultTy = op.getType().cast<RankedShapedType>();
     auto elementTy = inputTy.getElementType();
     int64_t rank = inputTy.getRank();
 
     ArrayRef<int64_t> multiples = op.getMultiples();
 
     // Broadcast the newly added dimensions to their appropriate multiple.
     SmallVector<int64_t, 2> genericShape;
     for (int i = 0; i < rank; i++) {
       int64_t dim = multiples[i];
-      genericShape.push_back(dim == -1 ? ShapedType::kDynamic : dim);
+      genericShape.push_back(dim == -1 ? RankedShapedType::kDynamic : dim);
       genericShape.push_back(inputShape[i]);
     }
 
     SmallVector<Value> dynDims;
     for (int i = 0; i < inputTy.getRank(); i++) {
       if (inputTy.isDynamicDim(i) || multiples[i] == -1) {
         dynDims.push_back(rewriter.create<tensor::DimOp>(loc, input, i));
       }

 class ArgMaxConverter : public OpRewritePattern<tosa::ArgMaxOp> {
 public:
   using OpRewritePattern<tosa::ArgMaxOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::ArgMaxOp argmaxOp,
                                 PatternRewriter &rewriter) const final {
     auto loc = argmaxOp.getLoc();
     Value input = argmaxOp.getInput();
-    auto inputTy = input.getType().cast<ShapedType>();
-    auto resultTy = argmaxOp.getOutput().getType().cast<ShapedType>();
+    auto inputTy = input.getType().cast<RankedShapedType>();
+    auto resultTy = argmaxOp.getOutput().getType().cast<RankedShapedType>();
     auto inElementTy = inputTy.getElementType();
     auto outElementTy = resultTy.getElementType();
     int axis = argmaxOp.getAxis();
     auto resultMaxTy = RankedTensorType::get(resultTy.getShape(), inElementTy);
 
     if (!outElementTy.isa<IntegerType>())
       return rewriter.notifyMatchFailure(
           argmaxOp,
public:
   LogicalResult
   matchAndRewrite(tosa::GatherOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     auto input = adaptor.getOperands()[0];
     auto indices = adaptor.getOperands()[1];
 
     auto valuesTy =
         op.getValues().getType().dyn_cast_or_null<RankedTensorType>();
-    auto resultTy = op.getType().cast<ShapedType>();
+    auto resultTy = op.getType().cast<RankedShapedType>();
 
     if (!valuesTy)
       return rewriter.notifyMatchFailure(op, "unranked tensors not supported");
 
     auto dynamicDims = inferDynamicDimsForGather(
         rewriter, op.getLoc(), adaptor.getValues(), adaptor.getIndices());
 
     auto resultElementTy = resultTy.getElementType();

 public:
   using OpRewritePattern<tosa::TableOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::TableOp op,
                                 PatternRewriter &rewriter) const final {
     auto loc = op.getLoc();
     Value input = op.getInput();
     Value table = op.getTable();
-    auto inputTy = input.getType().cast<ShapedType>();
+    auto inputTy = input.getType().cast<RankedShapedType>();
     auto tableTy = table.getType().cast<ShapedType>();
-    auto resultTy = op.getType().cast<ShapedType>();
+    auto resultTy = op.getType().cast<RankedShapedType>();
 
     auto inputElementTy = inputTy.getElementType();
     auto tableElementTy = tableTy.getElementType();
     auto resultElementTy = resultTy.getElementType();
 
     SmallVector<Value> dynDims;
     for (int i = 0; i < resultTy.getRank(); ++i) {
       if (inputTy.isDynamicDim(i)) {

mlir/lib/Conversion/TosaToLinalg/TosaToLinalgNamed.cpp

 using namespace mlir::tosa;
 
 static mlir::Value applyPad(Location loc, Value input, ArrayRef<int64_t> pad,
                             Attribute padAttr, OpBuilder &rewriter) {
   // Input should be padded if necessary.
   if (llvm::all_of(pad, [](int64_t p) { return p == 0; }))
     return input;
 
-  ShapedType inputTy = input.getType().cast<ShapedType>();
+  auto inputTy = input.getType().cast<RankedShapedType>();
   Type inputETy = inputTy.getElementType();
   auto inputShape = inputTy.getShape();
 
   assert((inputShape.size() * 2) == pad.size());
 
   SmallVector<int64_t, 4> paddedShape;
   SmallVector<OpFoldResult, 8> lowIndices;
   SmallVector<OpFoldResult, 8> highIndices;
   for (int i = 0, s = inputShape.size(); i < s; i++) {
     auto lowPad = pad[i * 2];
     auto highPad = pad[i * 2 + 1];
-    if (ShapedType::isDynamic(inputShape[i]))
+    if (RankedShapedType::isDynamic(inputShape[i]))
       paddedShape.push_back(inputShape[i]);
     else
       paddedShape.push_back(inputShape[i] + highPad + lowPad);
     lowIndices.push_back(rewriter.getIndexAttr(lowPad));
     highIndices.push_back(rewriter.getIndexAttr(highPad));
   }
 
   Value padValue = rewriter.create<arith::ConstantOp>(loc, padAttr);
 
   return rewriter.create<tensor::PadOp>(
       loc, RankedTensorType::get(paddedShape, inputETy), input, lowIndices,
       highIndices, padValue);
 }
 
 static mlir::Value
 linalgIntBroadcastExtSIAdd(PatternRewriter &rewriter, Location loc, Value bias,
                            Value conv, Value result,
                            ArrayRef<AffineMap> indexingMaps) {
-  ShapedType resultTy = conv.getType().cast<ShapedType>();
+  auto resultTy = conv.getType().cast<RankedShapedType>();
   return rewriter
       .create<linalg::GenericOp>(
           loc, resultTy, ValueRange({bias, conv}), result, indexingMaps,
           getNParallelLoopsAttrs(resultTy.getRank()),
           [](OpBuilder &builder, Location loc, ValueRange args) {
             Value biasVal = args[0];
             Type resType = args[1].getType();
             if (resType != biasVal.getType()) {
static mlir::Value getConvOutputDim(Location loc, Value inputDim,
   Value subtract = builder.create<arith::SubIOp>(paddedAfter, addOne);
   Value stride = reifyConstantDim(strideAttr, builder);
   Value divide = builder.create<arith::DivUIOp>(subtract, stride);
   return builder.create<arith::AddIOp>(divide, one);
 }
 
 // Creates a vector of the dynamic output dims for Conv2D and Depthwise_Conv2D
 static SmallVector<Value> inferDynamicDimsForConv(
-    Location loc, Value input, Value weight, ShapedType resultTy,
+    Location loc, Value input, Value weight, RankedShapedType resultTy,
     ArrayRef<int64_t> padAttr, ArrayRef<int64_t> strideAttr,
     ArrayRef<int64_t> dilationAttr, ArrayRef<int64_t> inputSizeDims,
     ArrayRef<int64_t> kernelSizeDims, OpBuilder &rewriter) {
-  ShapedType inputTy = input.getType().cast<ShapedType>();
+  auto inputTy = input.getType().cast<RankedShapedType>();
   Type inputETy = inputTy.getElementType();
   int64_t inputRank = inputTy.getRank();
 
   SmallVector<Value> dynDims;
   dynDims.resize(resultTy.getRank());
 
   for (uint32_t i = 0, s = inputSizeDims.size(); i < s; ++i) {
     int64_t inputDim = inputSizeDims[i];
public:
   LogicalResult
   matchAndRewrite(TosaConvOp op, typename TosaConvOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     Location loc = op->getLoc();
     Value input = op->getOperand(0);
     Value weight = op->getOperand(1);
     Value bias = op->getOperand(2);
 
-    ShapedType inputTy = input.getType().template cast<ShapedType>();
-    ShapedType weightTy = weight.getType().template cast<ShapedType>();
-    ShapedType biasTy = bias.getType().template cast<ShapedType>();
-    ShapedType resultTy =
-        op->getResult(0).getType().template cast<ShapedType>();
+    auto inputTy = input.getType().template cast<RankedShapedType>();
+    auto weightTy = weight.getType().template cast<RankedShapedType>();
+    auto biasTy = bias.getType().template cast<RankedShapedType>();
+    auto resultTy =
+        op->getResult(0).getType().template cast<RankedShapedType>();
 
     Type inputETy = inputTy.getElementType();
     Type resultETy = resultTy.getElementType();
 
     DenseI64ArrayAttr padAttr = op.getPadAttr();
     DenseI64ArrayAttr strideTosaAttr = op.getStrideAttr();
     DenseI64ArrayAttr dilationTosaAttr = op.getDilationAttr();
     bool isQuantized = op.getQuantizationInfo().has_value();
public:
   LogicalResult
   matchAndRewrite(tosa::DepthwiseConv2DOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     Location loc = op->getLoc();
     Value input = op->getOperand(0);
     Value weight = op->getOperand(1);
     Value bias = op->getOperand(2);
 
-    ShapedType inputTy = input.getType().cast<ShapedType>();
-    ShapedType weightTy = weight.getType().cast<ShapedType>();
-    ShapedType biasTy = bias.getType().cast<ShapedType>();
-    ShapedType resultTy = op->getResult(0).getType().cast<ShapedType>();
+    auto inputTy = input.getType().cast<RankedShapedType>();
+    auto weightTy = weight.getType().cast<RankedShapedType>();
+    auto biasTy = bias.getType().cast<RankedShapedType>();
+    auto resultTy = op->getResult(0).getType().cast<RankedShapedType>();
     int64_t resultRank = resultTy.getRank();
 
     Type inputETy = inputTy.getElementType();
     Type resultETy = resultTy.getElementType();
 
     auto padAttr = op->getAttr("pad").cast<DenseI64ArrayAttr>();
     auto strideTosaAttr = op->getAttr("stride").cast<DenseI64ArrayAttr>();
     auto dilationTosaAttr = op->getAttr("dilation").cast<DenseI64ArrayAttr>();
matchAndRewrite(tosa::DepthwiseConv2DOp op, OpAdaptor adaptor,
 
     // Extract the attributes for convolution.
     ArrayRef<int64_t> stride = strideTosaAttr;
     ArrayRef<int64_t> dilation = dilationTosaAttr;
 
     // Create the convolution op.
     auto strideAttr = rewriter.getI64TensorAttr(stride);
     auto dilationAttr = rewriter.getI64TensorAttr(dilation);
-    ShapedType linalgConvTy =
+    RankedShapedType linalgConvTy =
         RankedTensorType::get({resultShape[0], resultShape[1], resultShape[2],
                                weightShape[2], weightShape[3]},
                               resultETy);
 
     // Broadcast the initial value to the output tensor before convolving.
     SmallVector<AffineMap, 4> indexingMaps;
     indexingMaps.push_back(AffineMap::get(
         /*dimCount=*/resultRank, /*symbolCount=*/0,

 class MatMulConverter : public OpConversionPattern<tosa::MatMulOp> {
 public:
   using OpConversionPattern<tosa::MatMulOp>::OpConversionPattern;
   LogicalResult
   matchAndRewrite(tosa::MatMulOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     Location loc = op.getLoc();
 
-    auto outputTy = op.getType().cast<ShapedType>();
+    auto outputTy = op.getType().cast<RankedShapedType>();
     auto outputElementTy = outputTy.getElementType();
 
-    auto firstOperandTy = op->getOperand(0).getType().cast<ShapedType>();
-    auto secondOperandTy = op->getOperand(1).getType().cast<ShapedType>();
+    auto firstOperandTy =
+        op->getOperand(0).getType().dyn_cast<RankedShapedType>();
+    auto secondOperandTy =
+        op->getOperand(1).getType().dyn_cast<RankedShapedType>();
 
     SmallVector<Value> dynDims;
-    dynDims.resize(op->getResult(0).getType().cast<ShapedType>().getRank());
+    dynDims.resize(
+        op->getResult(0).getType().cast<RankedShapedType>().getRank());
 
-    if (!firstOperandTy.hasRank() || firstOperandTy.isDynamicDim(0)) {
+    if (!firstOperandTy || firstOperandTy.isDynamicDim(0)) {
       dynDims[0] = rewriter.create<tensor::DimOp>(loc, op->getOperand(0), 0);
     }
 
-    if (!firstOperandTy.hasRank() || firstOperandTy.isDynamicDim(1)) {
+    if (!firstOperandTy || firstOperandTy.isDynamicDim(1)) {
       dynDims[1] = rewriter.create<tensor::DimOp>(loc, op->getOperand(0), 1);
     }
 
-    if (!secondOperandTy.hasRank() || secondOperandTy.isDynamicDim(2)) {
+    if (!secondOperandTy || secondOperandTy.isDynamicDim(2)) {
       dynDims[2] = rewriter.create<tensor::DimOp>(loc, op->getOperand(1), 2);
     }
 
     SmallVector<Value> filteredDims = condenseValues(dynDims);
 
     auto zeroAttr = rewriter.getZeroAttr(outputElementTy);
     Value zero = rewriter.create<arith::ConstantOp>(loc, zeroAttr);
     auto emptyTensor = rewriter.create<tensor::EmptyOp>(

 class FullyConnectedConverter
     : public OpConversionPattern<tosa::FullyConnectedOp> {
 public:
   using OpConversionPattern<tosa::FullyConnectedOp>::OpConversionPattern;
   LogicalResult
   matchAndRewrite(tosa::FullyConnectedOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     Location loc = op.getLoc();
-    auto outputTy = op.getType().cast<ShapedType>();
+    auto outputTy = op.getType().cast<RankedShapedType>();
     auto input = op.getInput();
-    auto inputTy = input.getType().cast<ShapedType>();
+    auto inputTy = input.getType().dyn_cast<RankedShapedType>();
 
     auto bias = op.getBias();
 
     auto weight = op.getWeight();
-    auto weightTy = weight.getType().cast<ShapedType>();
+    auto weightTy = weight.getType().cast<RankedShapedType>();
     auto weightShape = weightTy.getShape();
 
     auto outputETy = outputTy.getElementType();
 
     SmallVector<Value> dynDims;
-    dynDims.resize(op->getResult(0).getType().cast<ShapedType>().getRank());
+    dynDims.resize(
+        op->getResult(0).getType().cast<RankedShapedType>().getRank());
 
-    if (!inputTy.hasRank() || inputTy.isDynamicDim(0)) {
+    if (!inputTy || inputTy.isDynamicDim(0)) {
       dynDims[0] = rewriter.create<tensor::DimOp>(loc, input, 0);
     }
 
-    if (!weightTy.hasRank() || weightTy.isDynamicDim(0)) {
+    if (weightTy.isDynamicDim(0)) {
       dynDims[1] = rewriter.create<tensor::DimOp>(loc, weight, 0);
     }
 
     SmallVector<Value> filteredDims = condenseValues(dynDims);
 
     // Creating maps for the output of MatMul and the bias
     SmallVector<AffineMap, 4> indexingMaps;
 
public:
   using OpRewritePattern<tosa::MaxPool2dOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::MaxPool2dOp op,
                                 PatternRewriter &rewriter) const final {
     Location loc = op.getLoc();
     Value input = op.getInput();
     ShapedType inputTy = input.getType().cast<ShapedType>();
 
-    ShapedType resultTy = op.getType().template cast<ShapedType>();
+    auto resultTy = op.getType().template cast<RankedShapedType>();
     Type resultETy = inputTy.getElementType();
 
     auto dynamicDimsOr =
         checkHasDynamicBatchDims(rewriter, op, {input, op.getOutput()});
     if (!dynamicDimsOr.has_value())
       return failure();
     SmallVector<Value> dynamicDims = *dynamicDimsOr;
 
public:
 
   LogicalResult matchAndRewrite(tosa::AvgPool2dOp op,
                                 PatternRewriter &rewriter) const final {
     Location loc = op.getLoc();
     Value input = op.getInput();
     ShapedType inputTy = input.getType().cast<ShapedType>();
     Type inElementTy = inputTy.getElementType();
 
-    ShapedType resultTy = op.getType().template cast<ShapedType>();
+    auto resultTy = op.getType().template cast<RankedShapedType>();
     Type resultETy = op.getType().cast<ShapedType>().getElementType();
 
     Type accETy =
         inElementTy.isa<IntegerType>() ? rewriter.getI32Type() : inElementTy;
-    ShapedType accTy = resultTy.clone(accETy);
+    auto accTy = resultTy.clone(accETy).cast<RankedShapedType>();
 
     auto dynamicDimsOr =
         checkHasDynamicBatchDims(rewriter, op, {input, op.getOutput()});
     if (!dynamicDimsOr.has_value())
       return failure();
     SmallVector<Value> dynamicDims = *dynamicDimsOr;
 
     // Apply padding as necessary.

mlir/lib/Conversion/TosaToTensor/TosaToTensor.cpp

 using namespace tosa;
 
 static bool findIntermediateShape(ArrayRef<int64_t> lhsShape,
                                   ArrayRef<int64_t> rhsShape,
                                   SmallVector<int64_t> &intermediateShape,
                                   bool isDynamic) {
   if (isDynamic) {
     // TODO (natashaknk): Make dynamic intermediate shape not always be rank-1
-    intermediateShape = {ShapedType::kDynamic};
+    intermediateShape = {RankedShapedType::kDynamic};
     return true;
   }
 
   if (lhsShape.empty() || rhsShape.empty()) {
     intermediateShape = {};
     return true;
   }
 

 namespace {
 class ReshapeConverterCollapse : public OpConversionPattern<tosa::ReshapeOp> {
 public:
   using OpConversionPattern<tosa::ReshapeOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(tosa::ReshapeOp reshape, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
-    ShapedType operandTy = adaptor.getInput1().getType().cast<ShapedType>();
-    ShapedType resultTy = reshape.getType().template cast<ShapedType>();
+    auto operandTy = adaptor.getInput1().getType().cast<RankedShapedType>();
+    auto resultTy = reshape.getType().template cast<RankedShapedType>();
     bool isDynamic = !operandTy.hasStaticShape();
 
     if (isDynamic && resultTy.getRank() != 1) {
       return rewriter.notifyMatchFailure(
           reshape, "Cannot collapse dynamic dims to more than one dimension");
     }
 
     SmallVector<ReassociationExprs, 4> reassociationMap;

 
 class ReshapeConverterExpand : public OpConversionPattern<tosa::ReshapeOp> {
 public:
   using OpConversionPattern<tosa::ReshapeOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(tosa::ReshapeOp reshape, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
-    ShapedType operandTy = adaptor.getInput1().getType().cast<ShapedType>();
-    ShapedType resultTy = reshape.getType().template cast<ShapedType>();
+    auto operandTy = adaptor.getInput1().getType().cast<RankedShapedType>();
+    auto resultTy = reshape.getType().template cast<RankedShapedType>();
     bool isDynamic = !operandTy.hasStaticShape();
 
     if (isDynamic && operandTy.getRank() != 1) {
       return rewriter.notifyMatchFailure(
           reshape, "Cannot expand dynamic dims from more than one dimension");
     }
 
     SmallVector<ReassociationExprs, 4> reassociationMap;

 class ReshapeConverterCollapseExpand
     : public OpConversionPattern<tosa::ReshapeOp> {
 public:
   using OpConversionPattern<tosa::ReshapeOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(tosa::ReshapeOp reshape, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
-    ShapedType operandTy = adaptor.getInput1().getType().cast<ShapedType>();
-    ShapedType resultTy = reshape.getType().template cast<ShapedType>();
+    auto operandTy = adaptor.getInput1().getType().cast<RankedShapedType>();
+    auto resultTy = reshape.getType().template cast<RankedShapedType>();
     bool isDynamic = !operandTy.hasStaticShape();
 
     SmallVector<int64_t> intermediateShape;
     if (!findIntermediateShape(resultTy.getShape(), operandTy.getShape(),
                                intermediateShape, isDynamic)) {
       return rewriter.notifyMatchFailure(
           reshape, "tosa.reshape Cannot identify an intermediate shape between "
                    "the given two shapes");
public:
 
   LogicalResult
   matchAndRewrite(tosa::SliceOp sliceOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     Location loc = sliceOp.getLoc();
     Value input = adaptor.getInput();
     SmallVector<int64_t> strides, sizes;
     ArrayRef<int64_t> starts = sliceOp.getStart();
-    strides.resize(sliceOp.getType().template cast<ShapedType>().getRank(), 1);
+    strides.resize(
+        sliceOp.getType().template cast<RankedShapedType>().getRank(), 1);
 
     SmallVector<Value> dynSizes;
     for (const auto &i : llvm::enumerate(sliceOp.getSize())) {
       int64_t size = i.value();
       size_t index = i.index();
-      sizes.push_back(size == -1 ? ShapedType::kDynamic : size);
-      if (!ShapedType::isDynamic(sizes.back()))
+      sizes.push_back(size == -1 ? RankedShapedType::kDynamic : size);
+      if (!RankedShapedType::isDynamic(sizes.back()))
         continue;
 
       auto dim = rewriter.create<tensor::DimOp>(loc, input, index);
       auto offset = rewriter.create<arith::ConstantOp>(
           loc, rewriter.getIndexAttr(starts[index]));
       dynSizes.push_back(rewriter.create<arith::SubIOp>(loc, dim, offset));
     }
 
public:
   using OpRewritePattern<tosa::PadOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::PadOp padOp,
                                 PatternRewriter &rewriter) const final {
     auto loc = padOp.getLoc();
     auto input = padOp.getInput1();
     auto padding = padOp.getPadding();
 
-    ShapedType inputTy = input.getType().cast<ShapedType>();
+    auto inputTy = input.getType().cast<RankedShapedType>();
     Type elementTy = inputTy.getElementType();
     int64_t rank = inputTy.getRank();
 
     // Setup the default constantAttr.
 
     Value padConstant;
 
     if (padOp.getPadConst()) {

 };
 
 struct ConcatConverter : public OpConversionPattern<tosa::ConcatOp> {
   using OpConversionPattern<tosa::ConcatOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(tosa::ConcatOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    auto inputType = op.getOperand(0).getType().template cast<ShapedType>();
+    auto inputType =
+        op.getOperand(0).getType().template cast<RankedShapedType>();
     auto resultType = op.getType().dyn_cast<RankedTensorType>();
 
     Location loc = op.getLoc();
     int axis = op.getAxis();
     Value axisValue = rewriter.createOrFold<arith::ConstantOp>(
         loc, rewriter.getIndexAttr(axis));
     int rank = resultType.getRank();
     SmallVector<Value, 3> offsets, sizes, strides;

mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp

getMemrefConstantHorizontalStride(ShapedType type) {
   if (memrefType.getRank() < 2)
     return 0;
   int64_t offset = 0;
   SmallVector<int64_t, 2> strides;
   if (failed(getStridesAndOffset(memrefType, strides, offset)) ||
       strides.back() != 1)
     return std::nullopt;
   int64_t stride = strides[strides.size() - 2];
-  if (stride == ShapedType::kDynamic)
+  if (stride == RankedShapedType::kDynamic)
     return std::nullopt;
   return stride;
 }
 
 // Return true if the transfer op can be converted to a MMA matrix load.
 static bool transferReadSupportsMMAMatrixType(vector::TransferReadOp readOp,
                                               bool useNvGpu) {
   if (readOp.getMask() || readOp.hasOutOfBoundsDim() ||

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

if (memRefType.getLayout().isIdentity())
     return strides;
 
   // Otherwise, we must determine contiguity form shapes. This can only ever
   // work in static cases because MemRefType is underspecified to represent
   // contiguous dynamic shapes in other ways than with just empty/identity
   // layout.
   auto sizes = memRefType.getShape();
   for (int index = 0, e = strides.size() - 1; index < e; ++index) {
-    if (ShapedType::isDynamic(sizes[index + 1]) ||
-        ShapedType::isDynamic(strides[index]) ||
-        ShapedType::isDynamic(strides[index + 1]))
+    if (RankedShapedType::isDynamic(sizes[index + 1]) ||
+        RankedShapedType::isDynamic(strides[index]) ||
+        RankedShapedType::isDynamic(strides[index + 1]))
       return std::nullopt;
     if (strides[index] != strides[index + 1] * sizes[index + 1])
       return std::nullopt;
   }
   return strides;
 }
 
 class VectorTypeCastOpConversion
matchAndRewrite(vector::TypeCastOp castOp, OpAdaptor adaptor,
     // Only contiguous source buffers supported atm.
     auto sourceStrides = computeContiguousStrides(sourceMemRefType);
     if (!sourceStrides)
       return failure();
     auto targetStrides = computeContiguousStrides(targetMemRefType);
     if (!targetStrides)
       return failure();
     // Only support static strides for now, regardless of contiguity.
-    if (llvm::any_of(*targetStrides, ShapedType::isDynamic))
+    if (llvm::any_of(*targetStrides, RankedShapedType::isDynamic))
       return failure();
 
     auto int64Ty = IntegerType::get(rewriter.getContext(), 64);
 
     // Create descriptor.
     auto desc = MemRefDescriptor::undef(rewriter, loc, llvmTargetDescriptorTy);
     Type llvmTargetElementTy = desc.getElementPtrType();
     // Set allocated ptr.

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

std::optional<int64_t> MemRefRegion::getConstantBoundingSizeAndShape(
   // memref dimension with static size added to guard against potential
   // over-approximation from projection or union bounding box. We may not add
   // this on the region itself since they might just be redundant constraints
   // that will need non-trivials means to eliminate.
   FlatAffineValueConstraints cstWithShapeBounds(cst);
   for (unsigned r = 0; r < rank; r++) {
     cstWithShapeBounds.addBound(BoundType::LB, r, 0);
     int64_t dimSize = memRefType.getDimSize(r);
-    if (ShapedType::isDynamic(dimSize))
+    if (RankedShapedType::isDynamic(dimSize))
       continue;
     cstWithShapeBounds.addBound(BoundType::UB, r, dimSize - 1);
   }
 
   // Find a constant upper bound on the extent of this memref region along each
   // dimension.
   int64_t numElements = 1;
   int64_t diffConstant;
   int64_t lbDivisor;
   for (unsigned d = 0; d < rank; d++) {
     SmallVector<int64_t, 4> lb;
     std::optional<int64_t> diff =
         cstWithShapeBounds.getConstantBoundOnDimSize64(d, &lb, &lbDivisor);
     if (diff.has_value()) {
       diffConstant = *diff;
       assert(diffConstant >= 0 && "Dim size bound can't be negative");
       assert(lbDivisor > 0);
     } else {
       // If no constant bound is found, then it can always be bound by the
       // memref's dim size if the latter has a constant size along this dim.
       auto dimSize = memRefType.getDimSize(d);
-      if (dimSize == ShapedType::kDynamic)
+      if (dimSize == RankedShapedType::kDynamic)
         return std::nullopt;
       diffConstant = dimSize;
       // Lower bound becomes 0.
       lb.resize(cstWithShapeBounds.getNumSymbolVars() + 1, 0);
       lbDivisor = 1;
     }
     numElements *= diffConstant;
     if (lbs) {

mlir/lib/Dialect/Affine/Transforms/PipelineDataTransfer.cpp

static bool doubleBuffer(Value oldMemRef, AffineForOp forOp) {
   auto oldMemRefType = oldMemRef.getType().cast<MemRefType>();
   auto newMemRefType = doubleShape(oldMemRefType);
 
   // The double buffer is allocated right before 'forOp'.
   OpBuilder bOuter(forOp);
   // Put together alloc operands for any dynamic dimensions of the memref.
   SmallVector<Value, 4> allocOperands;
   for (const auto &dim : llvm::enumerate(oldMemRefType.getShape())) {
-    if (dim.value() == ShapedType::kDynamic)
+    if (dim.value() == RankedShapedType::kDynamic)
       allocOperands.push_back(bOuter.createOrFold<memref::DimOp>(
           forOp.getLoc(), oldMemRef, dim.index()));
   }
 
   // Create and place the alloc right before the 'affine.for' operation.
   Value newMemRef = bOuter.create<memref::AllocOp>(
       forOp.getLoc(), newMemRefType, allocOperands);
 

mlir/lib/Dialect/Affine/Transforms/ReifyValueBounds.cpp

for (auto valueDim : mapOperands) {
 
     if (!dim.has_value()) {
       // This is an index-typed value.
       assert(value.getType().isIndex() && "expected index type");
       operands.push_back(value);
       continue;
     }
 
-    assert(cast<ShapedType>(value.getType()).isDynamicDim(*dim) &&
+    assert(cast<RankedShapedType>(value.getType()).isDynamicDim(*dim) &&
            "expected dynamic dim");
     if (isa<RankedTensorType>(value.getType())) {
       // A tensor dimension is used: generate a tensor.dim.
       operands.push_back(b.create<tensor::DimOp>(loc, value, *dim));
     } else if (isa<MemRefType>(value.getType())) {
       // A memref dimension is used: generate a memref.dim.
       operands.push_back(b.create<memref::DimOp>(loc, value, *dim));
     } else {

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

MemRefType mlir::normalizeMemRefType(MemRefType memrefType,
   fac.projectOut(newRank, fac.getNumVars() - newRank - fac.getNumLocalVars());
   SmallVector<int64_t, 4> newShape(newRank);
   MLIRContext *context = memrefType.getContext();
   for (unsigned d = 0; d < newRank; ++d) {
     // Check if this dimension is dynamic.
     bool isDynDim =
         isNormalizedMemRefDynamicDim(d, layoutMap, memrefTypeDynDims, context);
     if (isDynDim) {
-      newShape[d] = ShapedType::kDynamic;
+      newShape[d] = RankedShapedType::kDynamic;
     } else {
       // The lower bound for the shape is always zero.
       std::optional<int64_t> ubConst = fac.getConstantBound64(BoundType::UB, d);
       // For a static memref and an affine map with no symbols, this is
       // always bounded. However, when we have symbols, we may not be able to
       // obtain a constant upper bound. Also, mapping to a negative space is
       // invalid for normalization.
       if (!ubConst.has_value() || *ubConst < 0) {

mlir/lib/Dialect/Bufferization/IR/BufferizableOpInterface.cpp

if (shapedValue.getType().isa<RankedTensorType>() &&
         shapedValue.isa<OpResult>()) {
       ReifiedRankedShapedTypeDims resultDims;
       if (succeeded(
               reifyResultShapes(b, shapedValue.getDefiningOp(), resultDims))) {
         reifiedShapes = true;
         auto &shape =
             resultDims[shapedValue.cast<OpResult>().getResultNumber()];
         for (const auto &dim : enumerate(tensorType.getShape()))
-          if (ShapedType::isDynamic(dim.value()))
+          if (RankedShapedType::isDynamic(dim.value()))
             dynamicSizes.push_back(shape[dim.index()].get<Value>());
       }
     }
 
     // If the shape could not be reified, create DimOps.
     if (!reifiedShapes)
       populateDynamicDimSizes(b, loc, tensor, dynamicSizes);
   }
bufferization::getMemRefTypeWithFullyDynamicLayout(TensorType tensorType,
   // Case 1: Unranked memref type.
   if (auto unrankedTensorType = tensorType.dyn_cast<UnrankedTensorType>()) {
     return UnrankedMemRefType::get(unrankedTensorType.getElementType(),
                                    memorySpace);
   }
 
   // Case 2: Ranked memref type.
   auto rankedTensorType = tensorType.cast<RankedTensorType>();
-  int64_t dynamicOffset = ShapedType::kDynamic;
+  int64_t dynamicOffset = RankedShapedType::kDynamic;
   SmallVector<int64_t> dynamicStrides(rankedTensorType.getRank(),
-                                      ShapedType::kDynamic);
+                                      RankedShapedType::kDynamic);
   auto stridedLayout = StridedLayoutAttr::get(tensorType.getContext(),
                                               dynamicOffset, dynamicStrides);
   return MemRefType::get(rankedTensorType.getShape(),
                          rankedTensorType.getElementType(), stridedLayout,
                          memorySpace);
 }
 
 /// Return a MemRef type with a static identity layout (i.e., no layout map). If

mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp

mlir::bufferization::castOrReallocMemRefValue(OpBuilder &b, Value value,
   // at this point that it is really cast compatible).
   auto isGuaranteedCastCompatible = [](MemRefType source, MemRefType target) {
     int64_t sourceOffset, targetOffset;
     SmallVector<int64_t, 4> sourceStrides, targetStrides;
     if (failed(getStridesAndOffset(source, sourceStrides, sourceOffset)) ||
         failed(getStridesAndOffset(target, targetStrides, targetOffset)))
       return false;
     auto dynamicToStatic = [](int64_t a, int64_t b) {
-      return ShapedType::isDynamic(a) && !ShapedType::isDynamic(b);
+      return RankedShapedType::isDynamic(a) && !RankedShapedType::isDynamic(b);
     };
     if (dynamicToStatic(sourceOffset, targetOffset))
       return false;
     for (auto it : zip(sourceStrides, targetStrides))
       if (dynamicToStatic(std::get<0>(it), std::get<1>(it)))
         return false;
     return true;
   };
 
   // Note: If `areCastCompatible`, a cast is valid, but may fail at runtime. To
   // ensure that we only generate casts that always succeed at runtime, we check
   // a fix extra conditions in `isGuaranteedCastCompatible`.
   if (memref::CastOp::areCastCompatible(srcType, destType) &&
       isGuaranteedCastCompatible(srcType, destType)) {
     Value casted = b.create<memref::CastOp>(value.getLoc(), destType, value);
     return casted;
   }
 
   auto loc = value.getLoc();
   SmallVector<Value, 4> dynamicOperands;
   for (int i = 0; i < destType.getRank(); ++i) {
-    if (destType.getShape()[i] != ShapedType::kDynamic)
+    if (destType.getShape()[i] != RankedShapedType::kDynamic)
       continue;
     auto index = b.createOrFold<arith::ConstantIndexOp>(loc, i);
     Value size = b.create<memref::DimOp>(loc, value, index);
     dynamicOperands.push_back(size);
   }
   // TODO: Use alloc/memcpy callback from BufferizationOptions if called via
   // BufferizableOpInterface impl of ToMemrefOp.
   Value copy = b.create<memref::AllocOp>(loc, destType, dynamicOperands);
mlir::bufferization::foldToMemrefToTensorPair(RewriterBase &rewriter,
   rewriter.replaceOpWithNewOp<memref::CastOp>(toMemref, destType,
                                               memrefToTensor.getMemref());
   return success();
 }
 
 void mlir::bufferization::populateDynamicDimSizes(
     OpBuilder &b, Location loc, Value shapedValue,
     SmallVector<Value> &dynamicDims) {
-  auto shapedType = shapedValue.getType().cast<ShapedType>();
+  auto shapedType = shapedValue.getType().cast<RankedShapedType>();
   for (int64_t i = 0; i < shapedType.getRank(); ++i) {
     if (shapedType.isDynamicDim(i)) {
       if (shapedType.isa<MemRefType>()) {
         dynamicDims.push_back(b.create<memref::DimOp>(loc, shapedValue, i));
       } else {
         assert(shapedType.isa<RankedTensorType>() && "expected tensor");
         dynamicDims.push_back(b.create<tensor::DimOp>(loc, shapedValue, i));
       }

mlir/lib/Dialect/Bufferization/Transforms/BufferOptimizations.cpp

static bool isKnownControlFlowInterface(Operation *op) {
   return isa<LoopLikeOpInterface, RegionBranchOpInterface>(op);
 }
 
 /// Check if the size of the allocation is less than the given size. The
 /// transformation is only applied to small buffers since large buffers could
 /// exceed the stack space.
 static bool defaultIsSmallAlloc(Value alloc, unsigned maximumSizeInBytes,
                                 unsigned maxRankOfAllocatedMemRef) {
-  auto type = alloc.getType().dyn_cast<ShapedType>();
+  auto type = alloc.getType().dyn_cast<RankedShapedType>();
   if (!type || !alloc.getDefiningOp<memref::AllocOp>())
     return false;
   if (!type.hasStaticShape()) {
     // Check if the dynamic shape dimension of the alloc is produced by
     // `memref.rank`. If this is the case, it is likely to be small.
     // Furthermore, the dimension is limited to the maximum rank of the
     // allocated memref to avoid large values by multiplying several small
     // values.

mlir/lib/Dialect/Bufferization/Transforms/BufferResultsToOutParams.cpp

 using namespace mlir;
 
 /// Return `true` if the given MemRef type has a fully dynamic layout.
 static bool hasFullyDynamicLayoutMap(MemRefType type) {
   int64_t offset;
   SmallVector<int64_t, 4> strides;
   if (failed(getStridesAndOffset(type, strides, offset)))
     return false;
-  if (!llvm::all_of(strides, ShapedType::isDynamic))
+  if (!llvm::all_of(strides, RankedShapedType::isDynamic))
     return false;
-  if (!ShapedType::isDynamic(offset))
+  if (!RankedShapedType::isDynamic(offset))
     return false;
   return true;
 }
 
 /// Return `true` if the given MemRef type has a static identity layout (i.e.,
 /// no layout).
 static bool hasStaticIdentityLayout(MemRefType type) {
   return type.getLayout().isIdentity();

mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp

if (parser.parseLess() || parser.getCurrentLocation(&dimPos) ||
     return Type();
 
   // We parsed a generic dimension list, but vectors only support two forms:
   //  - single non-dynamic entry in the list (fixed vector);
   //  - two elements, the first dynamic (indicated by ShapedType::kDynamic)
   //  and the second
   //    non-dynamic (scalable vector).
   if (dims.empty() || dims.size() > 2 ||
-      ((dims.size() == 2) ^ (ShapedType::isDynamic(dims[0]))) ||
-      (dims.size() == 2 && ShapedType::isDynamic(dims[1]))) {
+      ((dims.size() == 2) ^ (RankedShapedType::isDynamic(dims[0]))) ||
+      (dims.size() == 2 && RankedShapedType::isDynamic(dims[1]))) {
     parser.emitError(dimPos)
         << "expected '? x <integer> x <type>' or '<integer> x <type>'";
     return Type();
   }
 
   bool isScalable = dims.size() == 2;
   if (isScalable)
     return parser.getChecked<LLVMScalableVectorType>(loc, elementType, dims[1]);

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

static Value createOrFoldDimOp(OpBuilder &b, Location loc, Value source,
   if (source.getType().isa<UnrankedMemRefType, MemRefType>())
     return b.createOrFold<memref::DimOp>(loc, source, dim);
   if (source.getType().isa<UnrankedTensorType, RankedTensorType>())
     return b.createOrFold<tensor::DimOp>(loc, source, dim);
   llvm_unreachable("Expected MemRefType or TensorType");
 }
 static OpFoldResult createFoldedDimOp(OpBuilder &b, Location loc, Value source,
                                       int64_t dim) {
-  auto shapedType = source.getType().cast<ShapedType>();
-  if (!shapedType.hasRank() || shapedType.isDynamicDim(dim))
+  auto shapedType = source.getType().dyn_cast<RankedShapedType>();
+  if (!shapedType || shapedType.isDynamicDim(dim))
     return createOrFoldDimOp(b, loc, source, dim);
   return b.getIndexAttr(shapedType.getDimSize(dim));
 }
 
 SmallVector<OpFoldResult> LinalgOp::createFlatListOfOperandDims(OpBuilder &b,
                                                                 Location loc) {
   SmallVector<OpFoldResult> res;
   for (OpOperand &opOperand : getOperation()->getOpOperands()) {
SmallVector<OpFoldResult> allResultDimValues =
       makeComposedFoldedMultiResultAffineApply(
           rewriter, loc, resultShapesFromInputShapesMap,
           createFlatListOfOperandDims(b, loc));
   int64_t pos = 0;
   ArrayRef<AffineExpr> shapeExprs = resultShapesFromInputShapesMap.getResults();
   for (OpOperand *opOperand : getDpsInitOperands()) {
     SmallVector<OpFoldResult> shapes;
     for (int64_t dim : llvm::seq<int64_t>(0, getRank(opOperand))) {
-      auto shapedType = opOperand->get().getType().cast<ShapedType>();
+      auto shapedType = opOperand->get().getType().cast<RankedShapedType>();
       if (!shapedType.isDynamicDim(dim)) {
         // Static dim: Return IntegerAttr.
         shapes.push_back(b.getIndexAttr(shapedType.getDimSize(dim)));
       } else {
         // Dynamic dim: Return Value.
         OpFoldResult ofr =
             checkDimExpr.visit(shapeExprs[pos])
                 ? createOrFoldDimOp(b, loc, opOperand->get(), dim)
if (!linalgOp.getShapesToLoopsMap())
     return op->emitOpError("expected the shape-to-loops map to be non-null");
 
   // Check if given shapes match to inferred shapes.
   SmallVector<int64_t, 4> endLoopRangeValues = linalgOp.getStaticLoopRanges();
   SmallVector<int64_t, 4> startLoopRangeValues(endLoopRangeValues.size(), 0);
 
   // Verify only static cases since we can't get exact dimension sizes and loop
   // ranges for dynamic cases in this stage.
-  if (llvm::none_of(endLoopRangeValues, ShapedType::isDynamic)) {
+  if (llvm::none_of(endLoopRangeValues, RankedShapedType::isDynamic)) {
     for (int64_t &range : endLoopRangeValues)
       range -= 1;
     for (OpOperand &opOperand : linalgOp->getOpOperands()) {
       AffineMap indexingMap = linalgOp.getMatchingIndexingMap(&opOperand);
       SmallVector<int64_t, 4> startIndices =
           indexingMap.compose(startLoopRangeValues);
       SmallVector<int64_t, 4> endIndices =
           indexingMap.compose(endLoopRangeValues);
       ArrayRef<int64_t> shape = linalgOp.getShape(&opOperand);
       for (auto dim : llvm::seq<int64_t>(0, shape.size())) {
         // Ignore dynamic dimension or the case that the dimension size is 0
-        if (ShapedType::isDynamic(shape[dim]) || shape[dim] == 0)
+        if (RankedShapedType::isDynamic(shape[dim]) || shape[dim] == 0)
           continue;
 
         // The first index or last index should be the maximum or the minimum in
         // the inferred index ranges since the range is increasing or
         // decreasing. The size of dimensions of input/output operands and the
         // maximum value + 1 in the inferred range should be the same. But, for
         // now we check if the inferred ranges are in boundary of input/output
         // operands' size or not in case that Affine Expressions are complicated

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

if (bbArgType != inputElemType) {
       return emitOpError() << "expected element type of input " << inputElemType
                            << " to match bbArg type " << bbArgType;
     }
   }
 
   // The shape of each input must match the shape of the output.
   auto outputShape = getInit().getType().getShape();
   for (Type inputArgType : TypeRange{getInputs()}) {
-    auto inputElemShape = inputArgType.cast<ShapedType>().getShape();
+    auto inputElemShape = inputArgType.cast<RankedShapedType>().getShape();
     if (inputElemShape != outputShape) {
       return emitOpError() << "expected shape of input (" << inputElemShape
                            << ") to match shape of output (" << outputShape
                            << ")";
     }
   }
 
   return success();
void ReduceOp::build(
   }
 
   if (bodyBuild)
     buildGenericRegion(builder, result.location, *result.regions.front(),
                        inputs, inits, bodyBuild);
 }
 
 SmallVector<utils::IteratorType> ReduceOp::getIteratorTypesArray() {
-  int64_t inputRank = getInputs()[0].getType().cast<ShapedType>().getRank();
+  int64_t inputRank =
+      getInputs()[0].getType().cast<RankedShapedType>().getRank();
   SmallVector<utils::IteratorType> iteratorTypes(inputRank,
                                                  utils::IteratorType::parallel);
   for (int64_t reductionDim : getDimensions())
     iteratorTypes[reductionDim] = utils::IteratorType::reduction;
   return iteratorTypes;
 }
 
 ArrayAttr ReduceOp::getIndexingMaps() {
-  int64_t inputRank = getInputs()[0].getType().cast<ShapedType>().getRank();
+  int64_t inputRank =
+      getInputs()[0].getType().cast<RankedShapedType>().getRank();
   SmallVector<AffineMap> affineMaps(
       getNumDpsInputs(),
       AffineMap::getMultiDimIdentityMap(inputRank, getContext()));
   AffineMap resultMap =
       AffineMap::getMultiDimIdentityMap(inputRank, getContext())
           .dropResults(getDimensions());
   for (int64_t i = 0, e = getNumDpsInits(); i < e; ++i)
     affineMaps.push_back(resultMap);
if (!payloadOp) {
     p.decreaseIndent();
   }
 }
 
 LogicalResult ReduceOp::verify() {
   ArrayRef<int64_t> dimensionsRef = getDimensions();
 
   for (int64_t i = 1; i < getNumDpsInputs(); ++i) {
-    if (getInputs()[i].getType().cast<ShapedType>().getShape() !=
-        getInputs()[0].getType().cast<ShapedType>().getShape()) {
+    if (getInputs()[i].getType().cast<RankedShapedType>().getShape() !=
+        getInputs()[0].getType().cast<RankedShapedType>().getShape()) {
       return emitOpError() << "expects all inputs to have the same shapes. "
                               "Shape at input-index "
                            << i
                            << " is not equal to the shape at input-index 0.";
     }
   }
   for (int64_t i = 1; i < getNumDpsInits(); ++i) {
-    if (getInits()[i].getType().cast<ShapedType>().getShape() !=
-        getInits()[0].getType().cast<ShapedType>().getShape()) {
+    if (getInits()[i].getType().cast<RankedShapedType>().getShape() !=
+        getInits()[0].getType().cast<RankedShapedType>().getShape()) {
       return emitOpError() << "expects all outputs to have the same shapes. "
                               "Shape at output-index "
                            << i
                            << " is not equal to the shape at output-index 0.";
     }
   }
-  auto inputType = getInputs()[0].getType().cast<ShapedType>();
-  auto initType = getInits()[0].getType().cast<ShapedType>();
+  auto inputType = getInputs()[0].getType().cast<RankedShapedType>();
+  auto initType = getInits()[0].getType().cast<RankedShapedType>();
 
   DenseSet<int64_t> dimensionsToReduce;
   for (int64_t dimension : dimensionsRef) {
     if (dimension < 0 || dimension >= inputType.getRank()) {
       return emitOpError()
              << "dimensions for reduction should be in the range [0, "
              << inputType.getRank() - 1 << "].";
     }

mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp

if (dynamicPointParseResult.has_value()) {
     if (failed(*dynamicPointParseResult) || parser.parseComma() ||
         parser.parseType(splitPointType) ||
         parser.resolveOperand(dynamicSplitPoint, splitPointType,
                               result.operands)) {
       return failure();
     }
 
     staticSplitPoint =
-        parser.getBuilder().getI64IntegerAttr(ShapedType::kDynamic);
+        parser.getBuilder().getI64IntegerAttr(RankedShapedType::kDynamic);
   }
 
   result.addAttribute(
       SplitOp::getStaticSplitPointAttrName(result.name).getValue(),
       staticSplitPoint);
   result.addTypes({targetType, targetType});
   return success();
 }
 
 void SplitOp::print(OpAsmPrinter &printer) {
   printer << " " << getTarget() << " after ";
   int64_t staticSplitSize = static_cast<int64_t>(getStaticSplitPoint());
-  if (staticSplitSize != ShapedType::kDynamic)
+  if (staticSplitSize != RankedShapedType::kDynamic)
     printer << staticSplitSize;
   else
     printer << getDynamicSplitPoint();
   printer << " ";
   printer.printOptionalAttrDict(getOperation()->getAttrs(),
                                 {getStaticSplitPointAttrName()});
   printer << " : " << getTarget().getType();
-  if (staticSplitSize == ShapedType::kDynamic)
+  if (staticSplitSize == RankedShapedType::kDynamic)
     printer << ", " << getDynamicSplitPoint().getType();
 }
 
 LogicalResult SplitOp::verify() {
-  if ((static_cast<int64_t>(getStaticSplitPoint()) != ShapedType::kDynamic) ^
+  if ((static_cast<int64_t>(getStaticSplitPoint()) !=
+       RankedShapedType::kDynamic) ^
       (getDynamicSplitPoint() == nullptr)) {
     return emitOpError() << "expects either a dynamic or a static split "
                             "point to be provided";
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//

 SmallVector<OpFoldResult> transform::TileOp::getMixedSizes() {
   ValueRange dynamic = getDynamicSizes();
   ArrayRef<int64_t> tileSizes = getStaticSizes();
   SmallVector<OpFoldResult> results;
   results.reserve(tileSizes.size());
   unsigned dynamicPos = 0;
   Builder builder(getContext());
   for (int64_t size : tileSizes) {
-    if (size == ShapedType::kDynamic) {
+    if (size == RankedShapedType::kDynamic) {
       results.push_back(dynamic[dynamicPos++]);
     } else {
       results.push_back(builder.getIndexAttr(size));
     }
   }
   return results;
 }
 

 SmallVector<OpFoldResult> transform::TileToScfForOp::getMixedSizes() {
   ValueRange dynamic = getDynamicSizes();
   ArrayRef<int64_t> tileSizes = getStaticSizes();
   SmallVector<OpFoldResult> results;
   results.reserve(tileSizes.size());
   unsigned dynamicPos = 0;
   Builder builder(getContext());
   for (int64_t size : tileSizes) {
-    if (size == ShapedType::kDynamic) {
+    if (size == RankedShapedType::kDynamic) {
       results.push_back(dynamic[dynamicPos++]);
     } else {
       results.push_back(builder.getIndexAttr(size));
     }
   }
   return results;
 }
 

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

LogicalResult matchAndRewrite(GenericOp genericOp,
     // Mixed and buffer sematics aren't supported.
     if (!genericOp.hasTensorSemantics())
       return failure();
 
     // Only support ops generating one output for now.
     if (genericOp.getNumDpsInits() != 1)
       return failure();
 
-    auto outputType = genericOp.getResultTypes().front().dyn_cast<ShapedType>();
+    auto outputType =
+        genericOp.getResultTypes().front().dyn_cast<RankedShapedType>();
     // Require the output types to be static given that we are generating
     // constants.
     if (!outputType || !outputType.hasStaticShape())
       return failure();
 
     if (!llvm::all_of(genericOp.getInputs(), [](Value input) {
           return input.getType().isa<ShapedType>();
         }))
LogicalResult matchAndRewrite(GenericOp genericOp,
     uint64_t dstLinearIndex = 0;
 
     // Allocate spaces for compute function inputs. Initial values do not matter
     // here as they will be overwritten later.
     APIntOrFloatArray computeFnInputs;
 
     auto inputShapes = llvm::to_vector<4>(
         llvm::map_range(genericOp.getInputs(), [](Value value) {
-          return value.getType().cast<ShapedType>().getShape();
+          return value.getType().cast<RankedShapedType>().getShape();
         }));
 
     // Given a `linearIndex`, remap it to a linear index to access linalg op
     // inputs/ouputs. This mutates `indices`, `srcIndices`, `dstIndices`,
     // `srcLinearIndices`, `dstLinearIndex` in place.
     auto computeRemappedLinearIndex = [&](int linearIndex) {
       int totalCount = linearIndex;
       for (int dim = loopBounds.size() - 1; dim >= 0; --dim) {

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

static Value getConvolvedIndex(OpBuilder &b, Location loc, Value oIndex,
   AffineExpr oExpr, fExpr;
   bindSymbols(b.getContext(), oExpr, fExpr);
   AffineMap convMap = AffineMap::get(0, 2, stride * oExpr + fExpr);
   return makeComposedAffineApply(b, loc, convMap, ValueRange{oIndex, fIndex});
 }
 
 FailureOr<std::pair<Operation *, Operation *>>
 rewriteInIm2Col(RewriterBase &rewriter, linalg::Conv2DNhwcHwcfOp convOp) {
-  auto inputType = convOp.getInputs()[0].getType().cast<ShapedType>();
-  auto filterType = convOp.getInputs()[1].getType().cast<ShapedType>();
-  auto outputType = convOp.getOutputs()[0].getType().cast<ShapedType>();
+  auto inputType = convOp.getInputs()[0].getType().dyn_cast<RankedShapedType>();
+  auto filterType =
+      convOp.getInputs()[1].getType().dyn_cast<RankedShapedType>();
+  auto outputType = convOp.getOutputs()[0].getType().cast<RankedShapedType>();
 
-  if (!filterType.hasStaticShape())
+  if (!filterType || !filterType.hasStaticShape())
     return rewriter.notifyMatchFailure(
         convOp, "expected a static shape for the filter");
 
-  if (!inputType.hasStaticShape())
+  if (!inputType || !inputType.hasStaticShape())
     return rewriter.notifyMatchFailure(convOp,
                                        "expected a static shape for the input");
 
   // TODO: Support dilation.
   if (!hasAllOneValues(convOp.getDilations()))
     return rewriter.notifyMatchFailure(convOp,
                                        "expected all ones for dilations");
 
rewriteInIm2Col(RewriterBase &rewriter,
 
   rewriter.replaceOp(convOp, ArrayRef<Value>{transposedResult});
   return std::make_pair(img2ColTensor.getOperation(),
                         transposedResult.getDefiningOp());
 }
 
 FailureOr<std::pair<Operation *, Operation *>>
 rewriteInIm2Col(RewriterBase &rewriter, linalg::Conv2DNchwFchwOp convOp) {
-  auto inputType = convOp.getInputs()[0].getType().cast<ShapedType>();
-  auto filterType = convOp.getInputs()[1].getType().cast<ShapedType>();
-  auto outputType = convOp.getOutputs()[0].getType().cast<ShapedType>();
+  auto inputType = convOp.getInputs()[0].getType().dyn_cast<RankedShapedType>();
+  auto filterType =
+      convOp.getInputs()[1].getType().dyn_cast<RankedShapedType>();
+  auto outputType = convOp.getOutputs()[0].getType().cast<RankedShapedType>();
 
-  if (!filterType.hasStaticShape())
+  if (!filterType || !filterType.hasStaticShape())
     return rewriter.notifyMatchFailure(
         convOp, "expected a static shape for the filter");
 
-  if (!inputType.hasStaticShape())
+  if (!inputType || !inputType.hasStaticShape())
     return rewriter.notifyMatchFailure(convOp,
                                        "expected a static shape for the input");
 
   // TODO: Support dilation.
   if (!hasAllOneValues(convOp.getDilations()))
     return rewriter.notifyMatchFailure(convOp,
                                        "expected all ones for dilations");
 

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

 namespace {
 /// Defines the criteria a TensorType must follow in order to be considered
 /// "detensorable".
 ///
 /// NOTE: For now, only 0-D tensors are supported.
 ///
 /// Returns true if tensorType can be detensored.
 bool canBeDetensored(TensorType tensorType) {
-  return tensorType.hasRank() && tensorType.getRank() == 0;
+  auto rankedTensorType = tensorType.dyn_cast<RankedTensorType>();
+  return rankedTensorType && rankedTensorType.getRank() == 0;
 }
 
 bool shouldBeDetensored(Operation *op, TypeConverter typeConverter) {
   GenericOp genericOp = dyn_cast_or_null<GenericOp>(op);
   return genericOp &&
          llvm::all_of(genericOp->getOpOperands(), [&](OpOperand &opOperand) {
            return !typeConverter.isLegal(opOperand.get().getType());
          });

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

static LogicalResult isGenericOpExpandable(GenericOp genericOp,
                                            PatternRewriter &rewriter) {
   if (!genericOp.hasIndexSemantics())
     return success();
   for (unsigned i : llvm::seq<unsigned>(0, expansionInfo.getOrigOpNumDims())) {
     ArrayRef<int64_t> expandedShape = expansionInfo.getExpandedShapeOfDim(i);
     if (expandedShape.size() == 1)
       continue;
     for (int64_t shape : expandedShape.drop_front()) {
-      if (ShapedType::isDynamic(shape)) {
+      if (RankedShapedType::isDynamic(shape)) {
         return rewriter.notifyMatchFailure(
             genericOp, "cannot expand due to index semantics and dynamic dims");
       }
     }
   }
   return success();
 }
 
ArrayRef<int64_t> expandedDimsShape =
         expansionInfo.getExpandedShapeOfDim(indexOp.getDim()).drop_front();
     SmallVector<Value> expandedIndices;
     expandedIndices.reserve(expandedDims.size() - 1);
     llvm::transform(
         expandedDims.drop_front(), std::back_inserter(expandedIndices),
         [&](int64_t dim) { return rewriter.create<IndexOp>(loc, dim); });
     Value newIndex = rewriter.create<IndexOp>(loc, expandedDims.front());
     for (auto it : llvm::zip(expandedDimsShape, expandedIndices)) {
-      assert(!ShapedType::isDynamic(std::get<0>(it)));
+      assert(!RankedShapedType::isDynamic(std::get<0>(it)));
       AffineExpr idx, acc;
       bindDims(rewriter.getContext(), idx, acc);
       newIndex = rewriter.create<AffineApplyOp>(
           indexOp.getLoc(), idx + acc * std::get<0>(it),
           ValueRange{std::get<1>(it), newIndex});
     }
     rewriter.replaceOp(indexOp, newIndex);
   }
FailureOr<SmallVector<Value>> mlir::linalg::collapseGenericOpIterationDims(
 
   // Insert expanding reshape for the result to get back the original result
   // type.
   SmallVector<Value> results;
   for (const auto &originalResult : llvm::enumerate(genericOp->getResults())) {
     Value collapsedOpResult =
         collapsedGenericOp->getResult(originalResult.index());
     auto originalResultType =
-        originalResult.value().getType().cast<ShapedType>();
-    auto collapsedOpResultType = collapsedOpResult.getType().cast<ShapedType>();
+        originalResult.value().getType().cast<RankedShapedType>();
+    auto collapsedOpResultType =
+        collapsedOpResult.getType().cast<RankedShapedType>();
     if (collapsedOpResultType.getRank() != originalResultType.getRank()) {
       AffineMap indexingMap =
           genericOp.getIndexingMapMatchingResult(originalResult.value());
       SmallVector<ReassociationIndices> reassociation =
           getOperandReassociation(indexingMap, collapsingInfo);
       Value result = rewriter.create<tensor::ExpandShapeOp>(
           loc, originalResultType, collapsedOpResult, reassociation);
       results.push_back(result);
for (OpOperand *opOperand : op.getDpsInitOperands()) {
 
         // If outs is already an `empty` operation, nothing to do.
         auto definingOp = operandVal.getDefiningOp<tensor::EmptyOp>();
         if (definingOp)
           continue;
         modifiedOutput = true;
         SmallVector<Value> dynamicDims;
         for (const auto &dim : llvm::enumerate(operandType.getShape())) {
-          if (dim.value() != ShapedType::kDynamic)
+          if (dim.value() != RankedShapedType::kDynamic)
             continue;
           dynamicDims.push_back(rewriter.createOrFold<tensor::DimOp>(
               loc, operandVal, dim.index()));
         }
         Value emptyTensor = rewriter.create<tensor::EmptyOp>(
             loc, operandType.getShape(), operandType.getElementType(),
             dynamicDims);
         op->setOperand(opOperand->getOperandNumber(), emptyTensor);

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

LogicalResult matchAndRewrite(tensor::PadOp padOp,
     // the source is the size of the slice.
     // TODO: This insert/extract could be potentially made a utility method.
     unsigned resultNumber = source.cast<OpResult>().getResultNumber();
     SmallVector<OpFoldResult> offsets = padOp.getMixedLowPad();
     SmallVector<OpFoldResult> sizes;
     sizes.reserve(offsets.size());
     for (const auto &shape : llvm::enumerate(
              source.getType().cast<RankedTensorType>().getShape())) {
-      if (ShapedType::isDynamic(shape.value())) {
+      if (RankedShapedType::isDynamic(shape.value())) {
         sizes.push_back(
             rewriter.create<tensor::DimOp>(loc, source, shape.index())
                 .getResult());
       } else {
         sizes.push_back(rewriter.getIndexAttr(shape.value()));
       }
     }
     SmallVector<OpFoldResult> strides(offsets.size(), rewriter.getIndexAttr(1));

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

static LinalgOp fuse(OpBuilder &b, LinalgOp producer,
   // fully dynamic at construction time.
   SmallVector<Type, 4> resultTypes;
   resultTypes.reserve(producer->getNumResults());
   for (OpOperand *operand : producer.getDpsInitOperands()) {
     auto tensorType = operand->get().getType().dyn_cast<RankedTensorType>();
     if (!tensorType)
       continue;
     unsigned rank = tensorType.getRank();
-    SmallVector<int64_t, 4> staticOffsetsVector(
-        rank, ShapedType::kDynamic);
-    SmallVector<int64_t, 4> staticSizesVector(rank, ShapedType::kDynamic);
-    SmallVector<int64_t, 4> staticStridesVector(
-        rank, ShapedType::kDynamic);
+    SmallVector<int64_t, 4> staticOffsetsVector(rank,
+                                                RankedShapedType::kDynamic);
+    SmallVector<int64_t, 4> staticSizesVector(rank, RankedShapedType::kDynamic);
+    SmallVector<int64_t, 4> staticStridesVector(rank,
+                                                RankedShapedType::kDynamic);
     resultTypes.push_back(tensor::ExtractSliceOp::inferResultType(
         tensorType, staticOffsetsVector, staticSizesVector,
         staticStridesVector));
   }
 
   Operation *clonedOp = clone(b, producer, resultTypes, clonedShapes);
 
   // Shift all IndexOp results by the tile offset.

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

static PackingResult buildPackingLoopNestImpl(
   offsets =
       SmallVector<OpFoldResult>{leadingHoistedPackedTensorIndexings.begin(),
                                 leadingHoistedPackedTensorIndexings.end()};
   offsets.append(paddedRank, rewriter.getIndexAttr(0));
   // sizes = [1 .. 1, transposedShape].
   sizes = SmallVector<OpFoldResult>(nPackedLoops, rewriter.getIndexAttr(1));
   for (int64_t sz : transposedTensorType.getShape()) {
     // TODO: go grab dims when needed, atm tensor::PadOp yields a static tensor.
-    assert(!ShapedType::isDynamic(sz) && "padded tensor needs static sizes");
+    assert(!RankedShapedType::isDynamic(sz) &&
+           "padded tensor needs static sizes");
     sizes.push_back(rewriter.getIndexAttr(sz));
   }
   // strides = [1 .. 1].
   strides = SmallVector<OpFoldResult>(nPackedLoops + paddedRank,
                                       rewriter.getIndexAttr(1));
 
   // Step 3. Optionally transpose the padded tensor.
   GenericOp maybeTransposeOp;
static FailureOr<PackingResult> buildPackingLoopNestImpl(
   FailureOr<RankedTensorType> transposedTensorType =
       tensor::computeTransposedType(paddedTensorType, transposeVector);
   if (failed(transposedTensorType)) {
     LLVM_DEBUG(DBGS() << "--Could not compute transposed type -> Skip\n");
     return failure();
   }
 
   // Create the packed tensor<?x?x..? x transposedShape>.
-  SmallVector<int64_t> packedShape(nPackedLoops, ShapedType::kDynamic);
+  SmallVector<int64_t> packedShape(nPackedLoops, RankedShapedType::kDynamic);
   // TODO: go grab dims when needed, atm tensor::PadOp yields a static tensor.
   llvm::append_range(packedShape, transposedTensorType->getShape());
   auto hoistedPackedTensorType = RankedTensorType::get(
       packedShape, transposedTensorType->getElementType());
 
   // Set the insertion point right before the outer loop and start packing.
   scf::ForOp outerLoop = analysis.outermostEnclosingForOp;
   OpBuilder::InsertionGuard g(rewriter);

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

if (options.useAlloca) {
                                               alignmentAttr);
     }
     return b.createOrFold<memref::AllocOp>(staticBufferType, ValueRange{},
                                            alignmentAttr);
   }
 
   // Fallback dynamic buffer.
   auto dynamicBufferType =
-      MemRefType::get(ShapedType::kDynamic, b.getIntegerType(8));
+      MemRefType::get(RankedShapedType::kDynamic, b.getIntegerType(8));
   Value mul = b.createOrFold<arith::MulIOp>(
       b.create<arith::ConstantIndexOp>(width), allocSize);
   if (options.useAlloca)
     return b.create<memref::AllocaOp>(dynamicBufferType, mul, alignmentAttr);
   return b.create<memref::AllocOp>(dynamicBufferType, mul, alignmentAttr);
 }
 
 /// Default allocation callback function. This allocates a promoted buffer when
static std::optional<Value> defaultAllocBufferCallBack(
   auto one = b.createOrFold<arith::ConstantIndexOp>(1);
 
   Value allocSize = one;
   for (const auto &size : llvm::enumerate(boundingSubViewSize))
     allocSize = b.createOrFold<arith::MulIOp>(allocSize, size.value());
   Value buffer = allocBuffer(b, options, viewType.getElementType(), allocSize,
                              layout, alignment);
   SmallVector<int64_t, 4> dynSizes(boundingSubViewSize.size(),
-                                   ShapedType::kDynamic);
+                                   RankedShapedType::kDynamic);
   Value view = b.createOrFold<memref::ViewOp>(
       MemRefType::get(dynSizes, viewType.getElementType()), buffer, zero,
       boundingSubViewSize);
   return view;
 }
 
 /// Default implementation of deallocation of the buffer use for promotion. It
 /// expects to get the same value that the default allocation method returned,
if (auto attr = rangeValue.size.dyn_cast<Attribute>()) {
                  ? materializedSize
                  : b.create<arith::ConstantIndexOp>(loc, *upperBound);
     }
     LLVM_DEBUG(llvm::dbgs() << "Extracted tightest: " << size << "\n");
     fullSizes.push_back(size);
     partialSizes.push_back(
         b.createOrFold<memref::DimOp>(loc, subView, resultDimIdx++));
   }
-  SmallVector<int64_t, 4> dynSizes(fullSizes.size(), ShapedType::kDynamic);
+  SmallVector<int64_t, 4> dynSizes(fullSizes.size(),
+                                   RankedShapedType::kDynamic);
   // If a callback is not specified, then use the default implementation for
   // allocating the promoted buffer.
   std::optional<Value> fullLocalView =
       allocationFn(b, subView, fullSizes, layout);
   if (!fullLocalView)
     return failure();
   SmallVector<OpFoldResult, 4> zeros(fullSizes.size(), b.getIndexAttr(0));
   SmallVector<OpFoldResult, 4> ones(fullSizes.size(), b.getIndexAttr(1));

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

FailureOr<SplitReductionResult> mlir::linalg::splitReduction(
   if (dims.size() != 1)
     return b.notifyMatchFailure(op, "needs a single reduction dimension");
   unsigned reductionDim = dims[0];
   if (control.innerParallel) {
     insertSplitDimension = reductionDim + 1;
   }
   SmallVector<int64_t, 4> loopRanges = op.getStaticLoopRanges();
   int64_t reductionDimSize = loopRanges[reductionDim];
-  if (reductionDimSize == ShapedType::kDynamic || reductionDimSize % ratio != 0)
+  if (reductionDimSize == RankedShapedType::kDynamic ||
+      reductionDimSize % ratio != 0)
     return b.notifyMatchFailure(
         op, "Reduction dimension not divisible by split ratio");
   if (op.getNumDpsInits() != 1)
     return b.notifyMatchFailure(op, "More than one output in split reduction");
   if (insertSplitIndex > op.getShape(op.getDpsInitOperand(0)).size())
     return b.notifyMatchFailure(op, "Insert dimension position too large "
                                     "compared to intermediate tensor size");
 
FailureOr<SplitReductionResult> mlir::linalg::splitReductionByScaling(
   SmallVector<unsigned> dims;
   op.getReductionDims(dims);
   if (dims.empty())
     return b.notifyMatchFailure(op, "needs at least 1 reduction dimension");
 
   unsigned reductionDimPos = dims[0];
   SmallVector<int64_t> loopRanges = op.getStaticLoopRanges();
   int64_t reductionDimSize = loopRanges[reductionDimPos];
-  if (reductionDimSize == ShapedType::kDynamic ||
+  if (reductionDimSize == RankedShapedType::kDynamic ||
       reductionDimSize % splitFactor != 0 ||
       insertSplitDimension >= loopRanges.size())
     return b.notifyMatchFailure(
         op, "first reduction dimension not divisible by split factor");
 
   SmallVector<Operation *> combinerOps;
   if (!matchReduction(op.getRegionOutputArgs(), 0, combinerOps))
     return b.notifyMatchFailure(op, "cannot match a reduction pattern");

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

FailureOr<Operation *> generateInitialTensorForPartialReduction(
     for (int64_t idx : llvm::seq<int64_t>(0, oldShape.size() + 1)) {
       if (idx == insertSplitDimension) {
         dispatchIndexOpFoldResults(sizes[idx], dynamicDims, newOutputShape);
         continue;
       }
       int64_t oldIdx = idx < insertSplitDimension ? idx : idx - 1;
       int64_t dim = oldShape[oldIdx];
       newOutputShape.push_back(dim);
-      if (ShapedType::isDynamic(dim))
+      if (RankedShapedType::isDynamic(dim))
         dynamicDims.push_back(b.createOrFold<tensor::DimOp>(
             loc, linalgOp.getDpsInitOperand(0)->get(), oldIdx));
     }
     Value emptyTensor = b.create<tensor::EmptyOp>(
         loc, newOutputShape, linalgOp.getRegionOutputArgs()[0].getType(),
         dynamicDims);
     Value constantOp = b.create<arith::ConstantOp>(loc, *identity);
     auto identityTensor =
Operation *mergeReductions(Operation *op, OpBuilder &b, Location loc,
     auto linalgOp = cast<LinalgOp>(op);
     assert(reductionDims.size() == 1 &&
            "only support single reduction right now.");
     int64_t dimToMerge = reductionDims[0];
 
     // Then create a new reduction that only reduce the newly added dimension
     // from the previous op.
     int64_t intermRank =
-        partialReduce[0].getType().cast<ShapedType>().getRank();
+        partialReduce[0].getType().cast<RankedShapedType>().getRank();
     AffineMap inputMap = b.getMultiDimIdentityMap(intermRank);
     SmallVector<utils::IteratorType> reductionIteratorTypes;
     SmallVector<AffineExpr> exprs;
     for (int64_t i : llvm::seq<int64_t>(0, intermRank)) {
       if (dimToMerge == i) {
         reductionIteratorTypes.push_back(utils::IteratorType::reduction);
       } else {
         exprs.push_back(b.getAffineDimExpr(i));

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

for (const auto &en : enumerate(indexingMap.getResults()))
         shapeDimsToPad.insert(en.index());
 
   // Return the unpadded operand if padding to a static shape is not needed and
   // if the nofold flag is not set.
   bool nofold = opOperand->getOperandNumber() < packPaddings.size()
                     ? packPaddings[opOperand->getOperandNumber()]
                     : false;
   bool hasStaticShape = llvm::none_of(shapeDimsToPad, [&](int64_t dim) {
-    return ShapedType::isDynamic(shape[dim]);
+    return RankedShapedType::isDynamic(shape[dim]);
   });
   if (!nofold && hasStaticShape)
     return opOperand->get();
 
   // Fail if `paddingValues` specifies no padding value.
   if (opOperand->getOperandNumber() >= paddingValues.size()) {
     return rewriter.notifyMatchFailure(opToPad, "--no padding value specified");
   }
for (const auto &en : enumerate(options.hoistPaddings)) {
     OpOperand &opOperand = paddedOp->getOpOperand(en.index());
     auto padOp = opOperand.get().getDefiningOp<tensor::PadOp>();
     if (!padOp || en.value() == 0) {
       (void)rewriter.notifyMatchFailure(linalgOp, "not a tensor.pad -- skip");
       continue;
     }
 
     // Fail hoisting if the operand shape is not fully static.
-    if (llvm::any_of(paddedOp.getShape(&opOperand), ShapedType::isDynamic)) {
+    if (llvm::any_of(paddedOp.getShape(&opOperand),
+                     RankedShapedType::isDynamic)) {
       (void)rewriter.notifyMatchFailure(linalgOp,
                                         "non static padding shape -- skip");
       continue;
     }
 
     tensor::PadOp hoistedOp;
     SmallVector<GenericOp> transposeOps;
     SmallVector<int64_t> transposeVector =

 ///
 /// Pattern to rewrite a tensor::PadOp into a sequence of EmptyOp, FillOp (to
 /// initialize with pad_val) and GenericOp (to copy contents).
 ///
 LogicalResult
 PadOpTransformationPattern::matchAndRewrite(tensor::PadOp padOp,
                                             PatternRewriter &rewriter) const {
 
-  auto inputShapedType = padOp.getSource().getType().cast<ShapedType>();
-  auto resultShapedType = padOp.getResult().getType().cast<ShapedType>();
+  auto inputShapedType = padOp.getSource().getType();
+  auto resultShapedType = padOp.getResult().getType();
 
   // Bail on non-static shapes.
   if (!inputShapedType.hasStaticShape())
     return failure();
   if (!resultShapedType.hasStaticShape())
     return failure();
 
   // Only support padding with a constant for now, i.e. either:

 static Value getPackOpSourceOrPaddedSource(OpBuilder &builder,
                                            tensor::PackOp packOp) {
   Value input = packOp.getSource();
   if (!packOp.getPaddingValue()) {
     return input;
   }
 
   Location loc = packOp.getLoc();
-  ShapedType inputType = packOp.getSourceType();
+  auto inputType = packOp.getSourceType();
   int64_t inputRank = inputType.getRank();
   assert(llvm::all_of(packOp.getDestType().getShape().take_front(inputRank),
                       [](int64_t val) { return val == 1; }));
 
   SmallVector<int64_t> paddedShape;
   DenseMap<int64_t, OpFoldResult> tileAndPosMapping =
       packOp.getDimAndTileMapping();
   for (int64_t dim = 0; dim < inputRank; ++dim) {
DenseMap<int64_t, OpFoldResult> dimAndTileMapping =
       packOp.getDimAndTileMapping();
   for (auto i : llvm::seq<unsigned>(0, srcRank)) {
     if (!dimAndTileMapping.count(i)) {
       readSizes.push_back(oneIdxAttr);
       continue;
     }
     readSizes.push_back(dimAndTileMapping[i]);
     readShape.push_back(getConstantIntValue(dimAndTileMapping[i])
-                            .value_or(ShapedType::kDynamic));
+                            .value_or(RankedShapedType::kDynamic));
   }
   Type elemType = packOp.getSourceType().getElementType();
   auto readType = RankedTensorType::get(readShape, elemType);
 
   Value input = getPackOpSourceOrPaddedSource(rewriter, packOp);
   Value tile = rewriter.create<tensor::ExtractSliceOp>(
       loc, readType, input, readOffsets, readSizes, readStrides);
 

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

private:
   OpBuilder::InsertionGuard rewriterGuard;
 };
 
 LogicalResult
 VectorizationState::precomputeIterSpaceValueSizes(RewriterBase &rewriter,
                                                   LinalgOp linalgOp) {
   // TODO: Support 0-d vectors.
   for (int vecDim = 0, end = canonicalVecShape.size(); vecDim < end; ++vecDim) {
-    if (!ShapedType::isDynamic(iterSpaceStaticSizes[vecDim])) {
+    if (!RankedShapedType::isDynamic(iterSpaceStaticSizes[vecDim])) {
       // Create constant index op for static dimensions.
       iterSpaceValueSizes.push_back(rewriter.create<arith::ConstantIndexOp>(
           linalgOp.getLoc(), iterSpaceStaticSizes[vecDim]));
       continue;
     }
 
     // Find an operand defined on this dimension of the iteration space to
     // extract the runtime dimension size.
if (!inputVectorSizes.empty()) {
     // dynamic shapes, the operation won't be vectorized.
     canonicalVecShape = linalgOp.getStaticLoopRanges();
   }
 
   LDBG("Canonical vector shape: ");
   LLVM_DEBUG(llvm::interleaveComma(canonicalVecShape, llvm::dbgs()));
   LLVM_DEBUG(llvm::dbgs() << "\n");
 
-  if (ShapedType::isDynamicShape(canonicalVecShape))
+  if (RankedShapedType::isDynamicShape(canonicalVecShape))
     return failure();
 
   // Initialize iteration space static sizes.
   initIterSpaceStaticSizes(linalgOp);
 
   // Generate 'arith.constant' and 'tensor/memref.dim' operations for
   // all the static and dynamic dimensions of the iteration space, needed to
   // compute a mask during vectorization.
getTensorExtractMemoryAccessPattern(tensor::ExtractOp extractOp,
   //    * an n-D vector, like`tensor<1x2x4xi32` or`tensor<2x1x4xi32>`, or
   //    * a 1-D vector with the trailing dim equal 1, e.g. `tensor<1x4x1xi32`.
   // TODO: Relax these conditions.
   if ((llvm::count_if(targetShape,
                       [](int64_t dimSize) { return dimSize > 1; }) != 1) ||
       targetShape.back() == 1)
     return VectorMemoryAccessKind::Gather;
 
-  auto inputShape = extractOp.getTensor().getType().cast<ShapedType>();
+  auto inputShape = extractOp.getTensor().getType();
 
   // 2. Assume that it's a gather load when reading _from_ a tensor for which
   // the trailing dimension is 1, e.g. `tensor<1x4x1xi32>`.
   // TODO: Relax this condition.
   if (inputShape.getShape().back() == 1)
     return VectorMemoryAccessKind::Gather;
 
   bool isContiguous = true;
mlir::linalg::vectorizeLinalgOpPrecondition(LinalgOp linalgOp,
   // tensor with dimension of 0 cannot be vectorized.
   if (llvm::any_of(linalgOp.getStaticShape(),
                    [](int64_t dim) { return dim == 0; }))
     return failure();
   // Check API contract for input vector sizes.
   if (!inputVectorSizes.empty()) {
     assert(inputVectorSizes.size() == linalgOp.getNumLoops() &&
            "Input vector sizes don't match the number of loops");
-    assert(!ShapedType::isDynamicShape(inputVectorSizes) &&
+    assert(!RankedShapedType::isDynamicShape(inputVectorSizes) &&
            "Input vector sizes can't have dynamic dimensions");
     assert(
         llvm::all_of(
             llvm::zip(linalgOp.getStaticLoopRanges(), inputVectorSizes),
             [](std::tuple<int64_t, int64_t> sizePair) {
               int64_t staticSize = std::get<0>(sizePair);
               int64_t inputSize = std::get<1>(sizePair);
-              return ShapedType::isDynamic(staticSize) ||
+              return RankedShapedType::isDynamic(staticSize) ||
                      staticSize <= inputSize;
             }) &&
         "Input vector sizes must be greater than or equal to iteration space "
         "static sizes");
   }
 
   if (linalgOp.hasDynamicShape() &&
       failed(vectorizeDynamicLinalgOpPrecondition(linalgOp))) {
LogicalResult rewriteUser(PatternRewriter &rewriter, tensor::PadOp padOp,
     // Only unit stride supported.
     if (!insertOp.hasUnitStride())
       return failure();
     // Pad value must be a constant.
     auto padValue = padOp.getConstantPaddingValue();
     if (!padValue)
       return failure();
     // Dynamic shapes not supported.
-    if (!padOp.getResult().getType().cast<ShapedType>().hasStaticShape())
+    if (!padOp.getResult().getType().hasStaticShape())
       return failure();
     // Pad result not used as destination.
     if (insertOp.getDest() == padOp.getResult())
       return failure();
 
     auto vecType = VectorType::get(padOp.getType().getShape(),
                                    padOp.getType().getElementType());
     unsigned vecRank = vecType.getRank();
LogicalResult LinalgCopyVTWForwardingPattern::matchAndRewrite(
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Convolution vectorization patterns
 //===----------------------------------------------------------------------===//
 
-template <int N>
-static void bindShapeDims(ShapedType shapedType) {}
+template <int N> static void bindShapeDims(RankedShapedType shapedType) {}
 
 template <int N, typename IntTy, typename... IntTy2>
-static void bindShapeDims(ShapedType shapedType, IntTy &val, IntTy2 &...vals) {
+static void bindShapeDims(RankedShapedType shapedType, IntTy &val,
+                          IntTy2 &...vals) {
   val = shapedType.getShape()[N];
   bindShapeDims<N + 1, IntTy2 &...>(shapedType, vals...);
 }
 
 /// Bind a pack of int& to the leading dimensions of shapedType.getShape().
 template <typename... IntTy>
-static void bindShapeDims(ShapedType shapedType, IntTy &...vals) {
+static void bindShapeDims(RankedShapedType shapedType, IntTy &...vals) {
   bindShapeDims<0>(shapedType, vals...);
 }
 
 namespace {
 bool isCastOfBlockArgument(Operation *op) {
   return isa<CastOpInterface>(op) && op->getNumOperands() == 1 &&
          op->getOperand(0).isa<BlockArgument>();
 }
Conv1DGenerator(RewriterBase &rewriter, LinalgOp linalgOp, int strideW,
       : StructuredGenerator<LinalgOp, utils::IteratorType>(rewriter, linalgOp),
         strideW(strideW), dilationW(dilationW) {
     // Determine whether `linalgOp` can be generated with this generator
     if (linalgOp.getNumDpsInputs() != 2 || linalgOp.getNumDpsInits() != 1)
       return;
     lhsShaped = linalgOp.getDpsInputOperand(0)->get();
     rhsShaped = linalgOp.getDpsInputOperand(1)->get();
     resShaped = linalgOp.getDpsInitOperand(0)->get();
-    lhsShapedType = lhsShaped.getType().dyn_cast<ShapedType>();
-    rhsShapedType = rhsShaped.getType().dyn_cast<ShapedType>();
-    resShapedType = resShaped.getType().dyn_cast<ShapedType>();
+    lhsShapedType = lhsShaped.getType().dyn_cast<RankedShapedType>();
+    rhsShapedType = rhsShaped.getType().dyn_cast<RankedShapedType>();
+    resShapedType = resShaped.getType().dyn_cast<RankedShapedType>();
     if (!lhsShapedType || !rhsShapedType || !resShapedType)
       return;
     // (LHS has dimension NCW/NWC and RES has dimension NFW/NCW/NWF/NWC) OR
     // (non-channeled convolution -> LHS and RHS both have single dimensions).
     if (!((lhsShapedType.getRank() == 3 && resShapedType.getRank() == 3) ||
           (lhsShapedType.getRank() == 1 && resShapedType.getRank() == 1)))
       return;
 
private:
   enum OperKind { Conv, Pool };
   bool valid = false;
   OperKind oper = Conv;
   StringAttr redOp;
   StringAttr poolExtOp;
   bool isPoolExt = false;
   int strideW, dilationW;
   Value lhsShaped, rhsShaped, resShaped;
-  ShapedType lhsShapedType, rhsShapedType, resShapedType;
+  RankedShapedType lhsShapedType, rhsShapedType, resShapedType;
 
   // Sets oper, poolExtOp and isPoolExt for valid conv/pooling ops.
   // Returns true iff it is a valid conv/pooling op.
   // If (region has 2 ops (reduction + yield) or 3 ops (extension + reduction
   // + yield) and rhs is not used) then it is the body of a pooling
   // If conv, check for single `mul` predecessor. The `mul` operands must be
   // block arguments or extension of block arguments.
   // Otherwise, check for one or zero `ext` predecessor. The `ext` operands

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

if (val.getType().isa<UnrankedMemRefType, MemRefType>())
     return b.createOrFold<memref::DimOp>(loc, val, dim);
   if (val.getType().isa<UnrankedTensorType, RankedTensorType>())
     return b.createOrFold<tensor::DimOp>(loc, val, dim);
   llvm_unreachable("Expected MemRefType or TensorType");
 }
 
 OpFoldResult createFoldedDimOp(OpBuilder &b, Location loc, Value val,
                                int64_t dim) {
-  auto shapedType = val.getType().cast<ShapedType>();
-  if (!shapedType.hasRank() || shapedType.isDynamicDim(dim))
+  auto shapedType = val.getType().dyn_cast<RankedShapedType>();
+  if (!shapedType || shapedType.isDynamicDim(dim))
     return createOrFoldDimOp(b, loc, val, dim);
   return b.getIndexAttr(shapedType.getDimSize(dim));
 }
 
 SmallVector<Value> createDynamicDimensions(OpBuilder &b, Location loc,
                                            Value val) {
-  auto shapedType = val.getType().cast<ShapedType>();
-  assert(shapedType.hasRank() && "`val` must have a static rank");
+  auto shapedType = val.getType().dyn_cast<RankedShapedType>();
+  assert(shapedType && "`val` must have a static rank");
   SmallVector<Value> res;
   res.reserve(shapedType.getRank());
   for (const auto &dim : llvm::enumerate(shapedType.getShape())) {
-    if (dim.value() == ShapedType::kDynamic)
+    if (dim.value() == RankedShapedType::kDynamic)
       res.push_back(createOrFoldDimOp(b, loc, val, dim.index()));
   }
   return res;
 }
 
 SmallVector<OpFoldResult> getMixedDimensions(OpBuilder &b, Location loc,
                                              Value val) {
-  auto shapedType = val.getType().cast<ShapedType>();
-  assert(shapedType.hasRank() && "`val` must have a static rank");
+  auto shapedType = val.getType().dyn_cast<RankedShapedType>();
+  assert(shapedType && "`val` must have a static rank");
   SmallVector<Value> dynamicDims = createDynamicDimensions(b, loc, val);
   return getMixedValues(shapedType.getShape(), dynamicDims, b);
 }
 } // namespace linalg
 } // namespace mlir

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

 }
 
 SliceParameters
 computeSliceParameters(OpBuilder &builder, Location loc, Value valueToTile,
                        ArrayRef<OpFoldResult> tileSizes, AffineMap map,
                        ArrayRef<OpFoldResult> lbs, ArrayRef<OpFoldResult> ubs,
                        ArrayRef<OpFoldResult> subShapeSizes,
                        bool omitPartialTileCheck) {
-  auto shapedType = valueToTile.getType().dyn_cast<ShapedType>();
+  auto shapedType = valueToTile.getType().dyn_cast<RankedShapedType>();
   assert(shapedType && "only shaped types can be tiled");
   ArrayRef<int64_t> shape = shapedType.getShape();
   int64_t rank = shapedType.getRank();
 
   // Compute offsets/sizes/strides for the tile.
   SliceParameters sliceParams;
   sliceParams.offsets.reserve(rank);
   sliceParams.sizes.reserve(rank);
for (unsigned r = 0; r < rank; ++r) {
     // The size of the subview / extract_slice should be trimmed to avoid
     // out-of-bounds accesses, unless:
     // a. We statically know the subshape size divides the shape size evenly.
     // b. The subshape size is 1. According to the way the loops are set up,
     //    tensors with "0" dimensions would never be constructed.
     int64_t shapeSize = shape[r];
     std::optional<int64_t> sizeCst = getConstantIntValue(size);
     auto hasTileSizeOne = sizeCst && *sizeCst == 1;
-    auto dividesEvenly = sizeCst && !ShapedType::isDynamic(shapeSize) &&
+    auto dividesEvenly = sizeCst && !RankedShapedType::isDynamic(shapeSize) &&
                          ((shapeSize % *sizeCst) == 0);
     if (!hasTileSizeOne && !dividesEvenly) {
       LLVM_DEBUG(llvm::dbgs() << "makeTiledShape: shapeSize=" << shapeSize
                               << ", size: " << size
                               << ": make sure in bound with affine.min\n");
 
       AffineExpr dim0, dim1, dim2;
       bindDims(builder.getContext(), dim0, dim1, dim2);

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

 using namespace mlir;
 using namespace mlir::memref;
 
 namespace {
 /// Idiomatic saturated operations on offsets, sizes and strides.
 namespace saturated_arith {
 struct Wrapper {
   static Wrapper stride(int64_t v) {
-    return (ShapedType::isDynamic(v)) ? Wrapper{true, 0}
-                                                    : Wrapper{false, v};
+    return (RankedShapedType::isDynamic(v)) ? Wrapper{true, 0}
   }
   static Wrapper offset(int64_t v) {
-    return (ShapedType::isDynamic(v)) ? Wrapper{true, 0}
-                                                    : Wrapper{false, v};
+    return (RankedShapedType::isDynamic(v)) ? Wrapper{true, 0}
   }
   static Wrapper size(int64_t v) {
-    return (ShapedType::isDynamic(v)) ? Wrapper{true, 0} : Wrapper{false, v};
-  }
-  int64_t asOffset() {
-    return saturated ? ShapedType::kDynamic : v;
-  }
-  int64_t asSize() { return saturated ? ShapedType::kDynamic : v; }
-  int64_t asStride() {
-    return saturated ? ShapedType::kDynamic : v;
+    return (RankedShapedType::isDynamic(v)) ? Wrapper{true, 0}
+                                            : Wrapper{false, v};
   }
+  int64_t asOffset() { return saturated ? RankedShapedType::kDynamic : v; }
+  int64_t asSize() { return saturated ? RankedShapedType::kDynamic : v; }
+  int64_t asStride() { return saturated ? RankedShapedType::kDynamic : v; }
   bool operator==(Wrapper other) {
     return (saturated && other.saturated) ||
            (!saturated && !other.saturated && v == other.v);
   }
   bool operator!=(Wrapper other) { return !(*this == other); }
   Wrapper operator+(Wrapper other) {
     if (saturated || other.saturated)
       return Wrapper{true, 0};

 ///     memref<f32> to memref<?x?xf32, strided<[?, 1], offset: ?>>
 /// ```
 /// `ReinterpretCastOp::getMixedStrides()` will return `[2, %dyn_stride]`.
 /// Now using this helper function with:
 /// - `values == [2, %dyn_stride]`,
 /// - `memRefTy == memref<?x?xf32, strided<[?, 1], offset: ?>>`
 /// - `getAttributes == getConstantStrides` (i.e., a wrapper around
 /// `getStridesAndOffset`), and
-/// - `isDynamic == ShapedType::isDynamic`
+/// - `isDynamic == RankedShapedType::isDynamic`
 /// Will yield: `values == [2, 1]`
 static void constifyIndexValues(
     SmallVectorImpl<OpFoldResult> &values, MemRefType memRefTy,
     MLIRContext *ctxt,
     llvm::function_ref<SmallVector<int64_t>(MemRefType)> getAttributes,
     llvm::function_ref<bool(int64_t)> isDynamic) {
   SmallVector<int64_t> constValues = getAttributes(memRefTy);
   Builder builder(ctxt);
LogicalResult matchAndRewrite(AllocLikeOp alloc,
     SmallVector<int64_t, 4> newShapeConstants;
     newShapeConstants.reserve(memrefType.getRank());
     SmallVector<Value, 4> dynamicSizes;
 
     unsigned dynamicDimPos = 0;
     for (unsigned dim = 0, e = memrefType.getRank(); dim < e; ++dim) {
       int64_t dimSize = memrefType.getDimSize(dim);
       // If this is already static dimension, keep it.
-      if (!ShapedType::isDynamic(dimSize)) {
+      if (!RankedShapedType::isDynamic(dimSize)) {
         newShapeConstants.push_back(dimSize);
         continue;
       }
       auto dynamicSize = alloc.getDynamicSizes()[dynamicDimPos];
       APInt constSizeArg;
       if (matchPattern(dynamicSize, m_ConstantInt(&constSizeArg)) &&
           constSizeArg.isNonNegative()) {
         // Dynamic shape dimension will be folded.
         newShapeConstants.push_back(constSizeArg.getZExtValue());
       } else {
         // Dynamic shape dimension not folded; copy dynamicSize from old memref.
-        newShapeConstants.push_back(ShapedType::kDynamic);
+        newShapeConstants.push_back(RankedShapedType::kDynamic);
         dynamicSizes.push_back(dynamicSize);
       }
       dynamicDimPos++;
     }
 
     // Create new memref type (which will have fewer dynamic dimensions).
     MemRefType newMemRefType =
         MemRefType::Builder(memrefType).setShape(newShapeConstants);
bool CastOp::canFoldIntoConsumerOp(CastOp castOp) {
   if (failed(getStridesAndOffset(sourceType, sourceStrides, sourceOffset)) ||
       failed(getStridesAndOffset(resultType, resultStrides, resultOffset)))
     return false;
 
   // If cast is towards more static sizes along any dimension, don't fold.
   for (auto it : llvm::zip(sourceType.getShape(), resultType.getShape())) {
     auto ss = std::get<0>(it), st = std::get<1>(it);
     if (ss != st)
-      if (ShapedType::isDynamic(ss) && !ShapedType::isDynamic(st))
+      if (RankedShapedType::isDynamic(ss) && !RankedShapedType::isDynamic(st))
         return false;
   }
 
   // If cast is towards more static offset along any dimension, don't fold.
   if (sourceOffset != resultOffset)
-    if (ShapedType::isDynamic(sourceOffset) &&
-        !ShapedType::isDynamic(resultOffset))
+    if (RankedShapedType::isDynamic(sourceOffset) &&
+        !RankedShapedType::isDynamic(resultOffset))
       return false;
 
   // If cast is towards more static strides along any dimension, don't fold.
   for (auto it : llvm::zip(sourceStrides, resultStrides)) {
     auto ss = std::get<0>(it), st = std::get<1>(it);
     if (ss != st)
-      if (ShapedType::isDynamic(ss) &&
-          !ShapedType::isDynamic(st))
+      if (RankedShapedType::isDynamic(ss) && !RankedShapedType::isDynamic(st))
         return false;
   }
 
   return true;
 }
 
 bool CastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   if (inputs.size() != 1 || outputs.size() != 1)
if (aT.getLayout() != bT.getLayout()) {
           aStrides.size() != bStrides.size())
         return false;
 
       // Strides along a dimension/offset are compatible if the value in the
       // source memref is static and the value in the target memref is the
       // same. They are also compatible if either one is dynamic (see
       // description of MemRefCastOp for details).
       auto checkCompatible = [](int64_t a, int64_t b) {
-        return (ShapedType::isDynamic(a) ||
-                ShapedType::isDynamic(b) || a == b);
+        return (RankedShapedType::isDynamic(a) ||
+                RankedShapedType::isDynamic(b) || a == b);
       };
       if (!checkCompatible(aOffset, bOffset))
         return false;
       for (const auto &aStride : enumerate(aStrides))
         if (!checkCompatible(aStride.value(), bStrides[aStride.index()]))
           return false;
     }
     if (aT.getMemorySpace() != bT.getMemorySpace())
       return false;
 
     // They must have the same rank, and any specified dimensions must match.
     if (aT.getRank() != bT.getRank())
       return false;
 
     for (unsigned i = 0, e = aT.getRank(); i != e; ++i) {
       int64_t aDim = aT.getDimSize(i), bDim = bT.getDimSize(i);
-      if (!ShapedType::isDynamic(aDim) && !ShapedType::isDynamic(bDim) &&
-          aDim != bDim)
+      if (!RankedShapedType::isDynamic(aDim) &&
+          !RankedShapedType::isDynamic(bDim) && aDim != bDim)
         return false;
     }
     return true;
   } else {
     if (!aT && !uaT)
       return false;
     if (!bT && !ubT)
       return false;
atLeastOneReplacement |= replaceConstantUsesOf(
       builder, getLoc(), getStrides(), getConstifiedMixedStrides());
 
   return success(atLeastOneReplacement);
 }
 
 SmallVector<OpFoldResult> ExtractStridedMetadataOp::getConstifiedMixedSizes() {
   SmallVector<OpFoldResult> values = getAsOpFoldResult(getSizes());
   constifyIndexValues(values, getSource().getType(), getContext(),
-                      getConstantSizes, ShapedType::isDynamic);
+                      getConstantSizes, RankedShapedType::isDynamic);
   return values;
 }
 
 SmallVector<OpFoldResult>
 ExtractStridedMetadataOp::getConstifiedMixedStrides() {
   SmallVector<OpFoldResult> values = getAsOpFoldResult(getStrides());
   constifyIndexValues(values, getSource().getType(), getContext(),
-                      getConstantStrides, ShapedType::isDynamic);
+                      getConstantStrides, RankedShapedType::isDynamic);
   return values;
 }
 
 OpFoldResult ExtractStridedMetadataOp::getConstifiedMixedOffset() {
   OpFoldResult offsetOfr = getAsOpFoldResult(getOffset());
   SmallVector<OpFoldResult> values(1, offsetOfr);
   constifyIndexValues(values, getSource().getType(), getContext(),
-                      getConstantOffset, ShapedType::isDynamic);
+                      getConstantOffset, RankedShapedType::isDynamic);
   return values[0];
 }
 
 //===----------------------------------------------------------------------===//
 // GenericAtomicRMWOp
 //===----------------------------------------------------------------------===//
 
 void GenericAtomicRMWOp::build(OpBuilder &builder, OperationState &result,

 
 //===----------------------------------------------------------------------===//
 // RankOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult RankOp::fold(FoldAdaptor adaptor) {
   // Constant fold rank when the rank of the operand is known.
   auto type = getOperand().getType();
-  auto shapedType = type.dyn_cast<ShapedType>();
-  if (shapedType && shapedType.hasRank())
+  auto shapedType = type.dyn_cast<RankedShapedType>();
+  if (shapedType)
     return IntegerAttr::get(IndexType::get(getContext()), shapedType.getRank());
   return IntegerAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // ReinterpretCastOp
 //===----------------------------------------------------------------------===//
 
return emitError("different memory spaces specified for source type ")
            << srcType << " and result memref type " << resultType;
   if (srcType.getElementType() != resultType.getElementType())
     return emitError("different element types specified for source type ")
            << srcType << " and result memref type " << resultType;
 
   // Match sizes in result memref type and in static_sizes attribute.
   for (auto [idx, resultSize, expectedSize] :
        llvm::enumerate(resultType.getShape(), getStaticSizes())) {
-    if (!ShapedType::isDynamic(resultSize) &&
-        !ShapedType::isDynamic(expectedSize) && resultSize != expectedSize)
+    if (!RankedShapedType::isDynamic(resultSize) &&
+        !RankedShapedType::isDynamic(expectedSize) &&
+        resultSize != expectedSize)
       return emitError("expected result type with size = ")
              << expectedSize << " instead of " << resultSize
              << " in dim = " << idx;
   }
 
   // Match offset and strides in static_offset and static_strides attributes. If
   // result memref type has no affine map specified, this will assume an
   // identity layout.
   int64_t resultOffset;
   SmallVector<int64_t, 4> resultStrides;
   if (failed(getStridesAndOffset(resultType, resultStrides, resultOffset)))
     return emitError("expected result type to have strided layout but found ")
            << resultType;
 
   // Match offset in result memref type and in static_offsets attribute.
   int64_t expectedOffset = getStaticOffsets().front();
-  if (!ShapedType::isDynamic(resultOffset) &&
-      !ShapedType::isDynamic(expectedOffset) &&
+  if (!RankedShapedType::isDynamic(resultOffset) &&
+      !RankedShapedType::isDynamic(expectedOffset) &&
       resultOffset != expectedOffset)
     return emitError("expected result type with offset = ")
            << expectedOffset << " instead of " << resultOffset;
 
   // Match strides in result memref type and in static_strides attribute.
   for (auto [idx, resultStride, expectedStride] :
        llvm::enumerate(resultStrides, getStaticStrides())) {
-    if (!ShapedType::isDynamic(resultStride) &&
-        !ShapedType::isDynamic(expectedStride) &&
+    if (!RankedShapedType::isDynamic(resultStride) &&
+        !RankedShapedType::isDynamic(expectedStride) &&
         resultStride != expectedStride)
       return emitError("expected result type with stride = ")
              << expectedStride << " instead of " << resultStride
              << " in dim = " << idx;
   }
 
   return success();
 }
OpFoldResult ReinterpretCastOp::fold(FoldAdaptor /*operands*/) {
   }
 
   return nullptr;
 }
 
 SmallVector<OpFoldResult> ReinterpretCastOp::getConstifiedMixedSizes() {
   SmallVector<OpFoldResult> values = getMixedSizes();
   constifyIndexValues(values, getType(), getContext(), getConstantSizes,
-                      ShapedType::isDynamic);
+                      RankedShapedType::isDynamic);
   return values;
 }
 
 SmallVector<OpFoldResult> ReinterpretCastOp::getConstifiedMixedStrides() {
   SmallVector<OpFoldResult> values = getMixedStrides();
   constifyIndexValues(values, getType(), getContext(), getConstantStrides,
-                      ShapedType::isDynamic);
+                      RankedShapedType::isDynamic);
   return values;
 }
 
 OpFoldResult ReinterpretCastOp::getConstifiedMixedOffset() {
   SmallVector<OpFoldResult> values = getMixedOffsets();
   assert(values.size() == 1 &&
          "reinterpret_cast must have one and only one offset");
   constifyIndexValues(values, getType(), getContext(), getConstantOffset,
-                      ShapedType::isDynamic);
+                      RankedShapedType::isDynamic);
   return values[0];
 }
 
 namespace {
 /// Replace the sequence:
 /// ```
 /// base, offset, sizes, strides = extract_strided_metadata src
 /// dst = reinterpret_cast base to offset, sizes, strides
for (int64_t expandedDim : group) {
       if (expandedDim != nextDim++)
         return op->emitOpError("reassociation indices must be contiguous");
 
       if (expandedDim >= static_cast<int64_t>(expandedShape.size()))
         return op->emitOpError("reassociation index ")
                << expandedDim << " is out of bounds";
 
       // Check if there are multiple dynamic dims in a reassociation group.
-      if (ShapedType::isDynamic(expandedShape[expandedDim])) {
+      if (RankedShapedType::isDynamic(expandedShape[expandedDim])) {
         if (foundDynamic && !allowMultipleDynamicDimsPerGroup)
           return op->emitOpError(
               "at most one dimension in a reassociation group may be dynamic");
         foundDynamic = true;
       }
     }
 
     // ExpandShapeOp/CollapseShapeOp may not be used to cast dynamicity.
-    if (ShapedType::isDynamic(collapsedShape[collapsedDim]) != foundDynamic)
+    if (RankedShapedType::isDynamic(collapsedShape[collapsedDim]) !=
+        foundDynamic)
       return op->emitOpError("collapsed dim (")
              << collapsedDim
              << ") must be dynamic if and only if reassociation group is "
                 "dynamic";
 
     // If all dims in the reassociation group are static, the size of the
     // collapsed dim can be verified.
     if (!foundDynamic) {
computeCollapsedLayoutMap(MemRefType srcType,
   // memref.transpose.) Dimensions of size 1 should be skipped, because their
   // strides are meaningless and could have any arbitrary value.
   SmallVector<int64_t> resultStrides;
   resultStrides.reserve(reassociation.size());
   for (const ReassociationIndices &reassoc : reassociation) {
     ArrayRef<int64_t> ref = llvm::ArrayRef(reassoc);
     while (srcShape[ref.back()] == 1 && ref.size() > 1)
       ref = ref.drop_back();
-    if (!ShapedType::isDynamic(srcShape[ref.back()]) || ref.size() == 1) {
+    if (!RankedShapedType::isDynamic(srcShape[ref.back()]) || ref.size() == 1) {
       resultStrides.push_back(srcStrides[ref.back()]);
     } else {
       // Dynamically-sized dims may turn out to be dims of size 1 at runtime, so
       // the corresponding stride may have to be skipped. (See above comment.)
       // Therefore, the result stride cannot be statically determined and must
       // be dynamic.
-      resultStrides.push_back(ShapedType::kDynamic);
+      resultStrides.push_back(RankedShapedType::kDynamic);
     }
   }
 
   // Validate that each reassociation group is contiguous.
   unsigned resultStrideIndex = resultStrides.size() - 1;
   for (const ReassociationIndices &reassoc : llvm::reverse(reassociation)) {
     auto trailingReassocs = ArrayRef<int64_t>(reassoc).drop_front();
     using saturated_arith::Wrapper;
if (auto operandMemRefType = operandType.dyn_cast<MemRefType>())
     if (!operandMemRefType.getLayout().isIdentity())
       return emitOpError("source memref type should have identity affine map");
 
   int64_t shapeSize = getShape().getType().cast<MemRefType>().getDimSize(0);
   auto resultMemRefType = resultType.dyn_cast<MemRefType>();
   if (resultMemRefType) {
     if (!resultMemRefType.getLayout().isIdentity())
       return emitOpError("result memref type should have identity affine map");
-    if (shapeSize == ShapedType::kDynamic)
+    if (shapeSize == RankedShapedType::kDynamic)
       return emitOpError("cannot use shape operand with dynamic length to "
                          "reshape to statically-ranked memref type");
     if (shapeSize != resultMemRefType.getRank())
       return emitOpError(
           "length of shape operand differs from the result's memref rank");
   }
   return success();
 }
void SubViewOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                             MLIRContext *context) {
   results
       .add<OpWithOffsetSizesAndStridesConstantArgumentFolder<
                SubViewOp, SubViewReturnTypeCanonicalizer, SubViewCanonicalizer>,
            SubViewOpMemRefCastFolder, TrivialSubViewOpFolder>(context);
 }
 
 OpFoldResult SubViewOp::fold(FoldAdaptor adaptor) {
-  auto resultShapedType = getResult().getType().cast<ShapedType>();
-  auto sourceShapedType = getSource().getType().cast<ShapedType>();
+  auto resultShapedType = getResult().getType().cast<RankedShapedType>();
+  auto sourceShapedType = getSource().getType().cast<RankedShapedType>();
 
   if (resultShapedType.hasStaticShape() &&
       resultShapedType == sourceShapedType) {
     return getViewSource();
   }
 
   // Fold subview(subview(x)), where both subviews have the same size and the
   // second subview's offsets are all zero. (I.e., the second subview is a
LogicalResult matchAndRewrite(ViewOp viewOp,
     SmallVector<int64_t, 4> newShapeConstants;
     newShapeConstants.reserve(memrefType.getRank());
 
     unsigned dynamicDimPos = 0;
     unsigned rank = memrefType.getRank();
     for (unsigned dim = 0, e = rank; dim < e; ++dim) {
       int64_t dimSize = memrefType.getDimSize(dim);
       // If this is already static dimension, keep it.
-      if (!ShapedType::isDynamic(dimSize)) {
+      if (!RankedShapedType::isDynamic(dimSize)) {
         newShapeConstants.push_back(dimSize);
         continue;
       }
       auto *defOp = viewOp.getSizes()[dynamicDimPos].getDefiningOp();
       if (auto constantIndexOp =
               dyn_cast_or_null<arith::ConstantIndexOp>(defOp)) {
         // Dynamic shape dimension will be folded.
         newShapeConstants.push_back(constantIndexOp.value());

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

resolveSubviewStridedMetadata(RewriterBase &rewriter,
   auto origStrides = newExtractStridedMetadata.getStrides();
 
   // Hold the affine symbols and values for the computation of the offset.
   SmallVector<OpFoldResult> values(2 * sourceRank + 1);
   SmallVector<AffineExpr> symbols(2 * sourceRank + 1);
 
   bindSymbolsList(rewriter.getContext(), MutableArrayRef{symbols});
   AffineExpr expr = symbols.front();
-  values[0] = ShapedType::isDynamic(sourceOffset)
+  values[0] = RankedShapedType::isDynamic(sourceOffset)
                   ? getAsOpFoldResult(newExtractStridedMetadata.getOffset())
                   : rewriter.getIndexAttr(sourceOffset);
   SmallVector<OpFoldResult> subOffsets = subview.getMixedOffsets();
 
   AffineExpr s0 = rewriter.getAffineSymbolExpr(0);
   AffineExpr s1 = rewriter.getAffineSymbolExpr(1);
   for (unsigned i = 0; i < sourceRank; ++i) {
     // Compute the stride.
     OpFoldResult origStride =
-        ShapedType::isDynamic(sourceStrides[i])
+        RankedShapedType::isDynamic(sourceStrides[i])
             ? origStrides[i]
             : OpFoldResult(rewriter.getIndexAttr(sourceStrides[i]));
     strides.push_back(makeComposedFoldedAffineApply(
         rewriter, origLoc, s0 * s1, {subStrides[i], origStride}));
 
     // Build up the computation of the offset.
     unsigned baseIdxForDim = 1 + 2 * i;
     unsigned subOffsetForDim = baseIdxForDim;
getExpandedSizes(memref::ExpandShapeOp expandShape, OpBuilder &builder,
 
   uint64_t productOfAllStaticSizes = 1;
   std::optional<unsigned> dynSizeIdx;
   MemRefType expandShapeType = expandShape.getResultType();
 
   // Fill up all the statically known sizes.
   for (unsigned i = 0; i < groupSize; ++i) {
     uint64_t dimSize = expandShapeType.getDimSize(reassocGroup[i]);
-    if (ShapedType::isDynamic(dimSize)) {
+    if (RankedShapedType::isDynamic(dimSize)) {
       assert(!dynSizeIdx && "There must be at most one dynamic size per group");
       dynSizeIdx = i;
       continue;
     }
     productOfAllStaticSizes *= dimSize;
     expandedSizes[i] = builder.getIndexAttr(dimSize);
   }
 
SmallVector<OpFoldResult> getExpandedStrides(memref::ExpandShapeOp expandShape,
 
   // Fill up the expanded strides, with the information we can deduce from the
   // resulting shape.
   uint64_t currentStride = 1;
   SmallVector<OpFoldResult> expandedStrides(groupSize);
   for (int i = groupSize - 1; i >= 0; --i) {
     expandedStrides[i] = builder.getIndexAttr(currentStride);
     uint64_t dimSize = expandShapeType.getDimSize(reassocGroup[i]);
-    if (ShapedType::isDynamic(dimSize)) {
+    if (RankedShapedType::isDynamic(dimSize)) {
       assert(!dynSizeIdx && "There must be at most one dynamic size per group");
       dynSizeIdx = i;
       continue;
     }
 
     currentStride *= dimSize;
   }
 
   // Collect the statically known information about the original stride.
   Value source = expandShape.getSrc();
   auto sourceType = source.getType().cast<MemRefType>();
   auto [strides, offset] = getStridesAndOffset(sourceType);
 
-  OpFoldResult origStride = ShapedType::isDynamic(strides[groupId])
+  OpFoldResult origStride = RankedShapedType::isDynamic(strides[groupId])
                                 ? origStrides[groupId]
                                 : builder.getIndexAttr(strides[groupId]);
 
   // Apply the original stride to all the strides.
   int64_t doneStrideIdx = 0;
   // If we saw a dynamic dimension, we need to fix-up all the strides up to
   // that dimension with the dynamic size.
   if (dynSizeIdx) {
     int64_t productOfAllStaticSizes = currentStride;
-    assert(ShapedType::isDynamic(sourceType.getDimSize(groupId)) &&
+    assert(RankedShapedType::isDynamic(sourceType.getDimSize(groupId)) &&
            "We shouldn't be able to change dynamicity");
     OpFoldResult origSize = origSizes[groupId];
 
     AffineExpr s0 = builder.getAffineSymbolExpr(0);
     AffineExpr s1 = builder.getAffineSymbolExpr(1);
     for (; doneStrideIdx < *dynSizeIdx; ++doneStrideIdx) {
       int64_t baseExpandedStride = expandedStrides[doneStrideIdx]
                                        .get<Attribute>()

 static SmallVector<OpFoldResult>
 getCollapsedSize(memref::CollapseShapeOp collapseShape, OpBuilder &builder,
                  ArrayRef<OpFoldResult> origSizes, unsigned groupId) {
   SmallVector<OpFoldResult> collapsedSize;
 
   MemRefType collapseShapeType = collapseShape.getResultType();
 
   uint64_t size = collapseShapeType.getDimSize(groupId);
-  if (!ShapedType::isDynamic(size)) {
+  if (!RankedShapedType::isDynamic(size)) {
     collapsedSize.push_back(builder.getIndexAttr(size));
     return collapsedSize;
   }
 
   // We are dealing with a dynamic size.
   // Build the affine expr of the product of the original sizes involved in that
   // group.
   Value source = collapseShape.getSrc();
   auto sourceType = source.getType().cast<MemRefType>();
 
   SmallVector<int64_t, 2> reassocGroup =
       collapseShape.getReassociationIndices()[groupId];
 
   collapsedSize.push_back(getProductOfValues(
       reassocGroup, builder, collapseShape.getLoc(), sourceType.getShape(),
-      origSizes, ShapedType::isDynamic));
+      origSizes, RankedShapedType::isDynamic));
 
   return collapsedSize;
 }
 
 /// Compute the collapsed stride of the given \p collpaseShape for the
 /// \p groupId-th reassociation group.
 /// \p origStrides and \p origSizes hold respectively the strides and sizes
 /// of the source shape as values.
for (int64_t currentDim : reassocGroup) {
     // meaningless.
     // FIXME: size-of-1 dimensions shouldn't be used in collapse shape, unless
     // they are truly contiguous. When they are truly contiguous, we shouldn't
     // need to skip them.
     if (srcShape[currentDim] == 1)
       continue;
 
     int64_t currentStride = strides[currentDim];
-    groupStrides.push_back(ShapedType::isDynamic(currentStride)
+    groupStrides.push_back(RankedShapedType::isDynamic(currentStride)
                                ? origStrides[currentDim]
                                : builder.getIndexAttr(currentStride));
   }
   if (groupStrides.empty()) {
     // We're dealing with a 1x1x...x1 shape. The stride is meaningless,
     // but we still have to make the type system happy.
     MemRefType collapsedType = collapseShape.getResultType();
     auto [collapsedStrides, collapsedOffset] =
         getStridesAndOffset(collapsedType);
     int64_t finalStride = collapsedStrides[groupId];
-    if (ShapedType::isDynamic(finalStride)) {
+    if (RankedShapedType::isDynamic(finalStride)) {
       // Look for a dynamic stride. At this point we don't know which one is
       // desired, but they are all equally good/bad.
       for (int64_t currentDim : reassocGroup) {
         assert(srcShape[currentDim] == 1 &&
                "We should be dealing with 1x1x...x1");
 
-        if (ShapedType::isDynamic(strides[currentDim]))
+        if (RankedShapedType::isDynamic(strides[currentDim]))
           return {origStrides[currentDim]};
       }
       llvm_unreachable("We should have found a dynamic stride");
     }
     return {builder.getIndexAttr(finalStride)};
   }
 
   // For the general case, we just want the minimum stride
auto newExtractStridedMetadata =
         rewriter.create<memref::ExtractStridedMetadataOp>(origLoc, source);
 
     // Collect statically known information.
     auto [strides, offset] = getStridesAndOffset(sourceType);
     MemRefType reshapeType = reshape.getResultType();
     unsigned reshapeRank = reshapeType.getRank();
 
     OpFoldResult offsetOfr =
-        ShapedType::isDynamic(offset)
+        RankedShapedType::isDynamic(offset)
             ? getAsOpFoldResult(newExtractStridedMetadata.getOffset())
             : rewriter.getIndexAttr(offset);
 
     // Get the special case of 0-D out of the way.
     if (sourceRank == 0) {
       SmallVector<OpFoldResult> ones(reshapeRank, rewriter.getIndexAttr(1));
       auto memrefDesc = rewriter.create<memref::ReinterpretCastOp>(
           origLoc, reshapeType, newExtractStridedMetadata.getBaseBuffer(),
LogicalResult matchAndRewrite(memref::ExtractStridedMetadataOp op,
     int rank = memRefType.getRank();
 
     // Collect the sizes.
     ValueRange dynamic = allocLikeOp.getDynamicSizes();
     SmallVector<OpFoldResult> sizes;
     sizes.reserve(rank);
     unsigned dynamicPos = 0;
     for (int64_t size : memRefType.getShape()) {
-      if (ShapedType::isDynamic(size))
+      if (RankedShapedType::isDynamic(size))
         sizes.push_back(dynamic[dynamicPos++]);
       else
         sizes.push_back(rewriter.getIndexAttr(size));
     }
 
     // Strides (just creates identity strides).
     SmallVector<OpFoldResult> strides(rank, rewriter.getIndexAttr(1));
     AffineExpr expr = rewriter.getAffineConstantExpr(1);
if (!memRefType.getLayout().isIdentity()) {
           "get-global operation result should have been normalized");
     }
 
     Location loc = op.getLoc();
     int rank = memRefType.getRank();
 
     // Collect the sizes.
     ArrayRef<int64_t> sizes = memRefType.getShape();
-    assert(!llvm::any_of(sizes, ShapedType::isDynamic) &&
+    assert(!llvm::any_of(sizes, RankedShapedType::isDynamic) &&
            "unexpected dynamic shape for result of `memref.get_global` op");
 
     // Strides (just creates identity strides).
     SmallVector<int64_t> strides = computeSuffixProduct(sizes);
 
     // Put all the values together to replace the results.
     SmallVector<Value> results;
     results.reserve(rank * 2 + 2);

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

if (srcType.isa<UnrankedMemRefType>()) {
       builder.create<cf::AssertOp>(loc, isSameRank,
                                    generateErrorMessage(op, "rank mismatch"));
     }
 
     // Get source offset and strides. We do not have an op to get offsets and
     // strides from unranked memrefs, so cast the source to a type with fully
     // dynamic layout, from which we can then extract the offset and strides.
     // (Rank was already verified.)
-    int64_t dynamicOffset = ShapedType::kDynamic;
+    int64_t dynamicOffset = RankedShapedType::kDynamic;
     SmallVector<int64_t> dynamicShape(resultType.getRank(),
-                                      ShapedType::kDynamic);
+                                      RankedShapedType::kDynamic);
     auto stridedLayout = StridedLayoutAttr::get(builder.getContext(),
                                                 dynamicOffset, dynamicShape);
     auto dynStridesType =
         MemRefType::get(dynamicShape, resultType.getElementType(),
                         stridedLayout, resultType.getMemorySpace());
     Value helperCast =
         builder.create<CastOp>(loc, dynStridesType, castOp.getSource());
     auto metadataOp = builder.create<ExtractStridedMetadataOp>(loc, helperCast);
void generateRuntimeVerification(Operation *op, OpBuilder &builder,
 
     // Get result offset and strides.
     int64_t resultOffset;
     SmallVector<int64_t> resultStrides;
     if (failed(getStridesAndOffset(resultType, resultStrides, resultOffset)))
       return;
 
     // Check offset.
-    if (resultOffset != ShapedType::kDynamic) {
+    if (resultOffset != RankedShapedType::kDynamic) {
       // Static/dynamic offset -> dynamic offset does not need verification.
       Value srcOffset = metadataOp.getResult(1);
       Value resultOffsetVal =
           builder.create<arith::ConstantIndexOp>(loc, resultOffset);
       Value isSameOffset = builder.create<arith::CmpIOp>(
           loc, arith::CmpIPredicate::eq, srcOffset, resultOffsetVal);
       builder.create<cf::AssertOp>(loc, isSameOffset,
                                    generateErrorMessage(op, "offset mismatch"));
     }
 
     // Check strides.
     for (const auto &it : llvm::enumerate(resultStrides)) {
       // Static/dynamic stride -> dynamic stride does not need verification.
-      if (it.value() == ShapedType::kDynamic)
+      if (it.value() == RankedShapedType::kDynamic)
         continue;
 
       Value srcStride =
           metadataOp.getResult(2 + resultType.getRank() + it.index());
       Value resultStrideVal =
           builder.create<arith::ConstantIndexOp>(loc, it.value());
       Value isSameStride = builder.create<arith::CmpIOp>(
           loc, arith::CmpIPredicate::eq, srcStride, resultStrideVal);

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

 
 Type QuantizedType::castToStorageType(Type quantizedType) {
   if (quantizedType.isa<QuantizedType>()) {
     // i.e. quant<"uniform[i8:f32]{1.0}"> -> i8
     return quantizedType.cast<QuantizedType>().getStorageType();
   }
   if (quantizedType.isa<ShapedType>()) {
     // i.e. tensor<4xi8> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
-    ShapedType sType = quantizedType.cast<ShapedType>();
+    RankedShapedType sType = quantizedType.cast<RankedShapedType>();
     if (!sType.getElementType().isa<QuantizedType>()) {
       return nullptr;
     }
     Type storageType =
         sType.getElementType().cast<QuantizedType>().getStorageType();
     if (quantizedType.isa<RankedTensorType>()) {
       return RankedTensorType::get(sType.getShape(), storageType);
     }

 }
 
 Type QuantizedType::castFromExpressedType(Type candidateType) {
   if (candidateType == getExpressedType()) {
     // i.e. f32 -> quant<"uniform[i8:f32]{1.0}">
     return *this;
   }
   if (candidateType.isa<ShapedType>()) {
-    ShapedType candidateShapedType = candidateType.cast<ShapedType>();
+    RankedShapedType candidateShapedType =
+        candidateType.cast<RankedShapedType>();
     if (candidateShapedType.getElementType() != getExpressedType()) {
       return nullptr;
     }
 
     if (candidateType.isa<RankedTensorType>()) {
       // i.e. tensor<4xf32> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
       return RankedTensorType::get(candidateShapedType.getShape(), *this);
     }

 
 Type QuantizedType::castToExpressedType(Type quantizedType) {
   if (quantizedType.isa<QuantizedType>()) {
     // i.e. quant<"uniform[i8:f32]{1.0}"> -> f32
     return quantizedType.cast<QuantizedType>().getExpressedType();
   }
   if (quantizedType.isa<ShapedType>()) {
     // i.e. tensor<4xi8> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
-    ShapedType sType = quantizedType.cast<ShapedType>();
+    RankedShapedType sType = quantizedType.cast<RankedShapedType>();
     if (!sType.getElementType().isa<QuantizedType>()) {
       return nullptr;
     }
     Type expressedType =
         sType.getElementType().cast<QuantizedType>().getExpressedType();
     if (quantizedType.isa<RankedTensorType>()) {
       return RankedTensorType::get(sType.getShape(), expressedType);
     }

mlir/lib/Dialect/Quant/Utils/UniformSupport.cpp

UniformQuantizedPerAxisValueConverter::convert(Attribute realValue) {
   // TODO: handles sparse elements attribute
   return nullptr;
 }
 
 DenseElementsAttr
 UniformQuantizedPerAxisValueConverter::convert(DenseFPElementsAttr attr) {
   // Creates the converter for each chunk. Normally the size of the
   // quantization dim is 3, so we can cache all the converters.
-  ShapedType type = attr.getType();
+  RankedShapedType type = attr.getType();
   size_t dimSize = type.getDimSize(quantizationDim);
   if (dimSize != scales.size()) {
     return {};
   }
   SmallVector<UniformQuantizedValueConverter, 4> converters;
   converters.reserve(dimSize);
   for (int i = 0, e = dimSize; i != e; ++i) {
     converters.push_back(getPerChunkConverter(i));

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

if (valueType != opType)
              << opType << ") does not match value type (" << valueType << ")";
     return success();
   }
   if (value.isa<DenseIntOrFPElementsAttr, SparseElementsAttr>()) {
     auto valueType = value.cast<TypedAttr>().getType();
     if (valueType == opType)
       return success();
     auto arrayType = opType.dyn_cast<spirv::ArrayType>();
-    auto shapedType = valueType.dyn_cast<ShapedType>();
+    auto shapedType = valueType.dyn_cast<RankedShapedType>();
     if (!arrayType)
       return op.emitOpError("result or element type (")
              << opType << ") does not match value type (" << valueType
              << "), must be the same or spirv.array";
 
     int numElements = arrayType.getNumElements();
     auto opElemType = arrayType.getElementType();
     while (auto t = opElemType.dyn_cast<spirv::ArrayType>()) {

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

if (auto memRefType = type.dyn_cast<MemRefType>()) {
     auto elementSize = getTypeNumBytes(options, memRefType.getElementType());
     if (!elementSize)
       return std::nullopt;
 
     if (memRefType.getRank() == 0)
       return elementSize;
 
     auto dims = memRefType.getShape();
-    if (llvm::is_contained(dims, ShapedType::kDynamic) ||
-        ShapedType::isDynamic(offset) ||
-        llvm::is_contained(strides, ShapedType::kDynamic))
+    if (llvm::is_contained(dims, RankedShapedType::kDynamic) ||
+        RankedShapedType::isDynamic(offset) ||
+        llvm::is_contained(strides, RankedShapedType::kDynamic))
       return std::nullopt;
 
     int64_t memrefSize = -1;
     for (const auto &shape : enumerate(dims))
       memrefSize = std::max(memrefSize, shape.value() * strides[shape.index()]);
 
     return (offset + memrefSize) * *elementSize;
   }
 
-  if (auto tensorType = type.dyn_cast<TensorType>()) {
+  if (auto tensorType = type.dyn_cast<RankedTensorType>()) {
     if (!tensorType.hasStaticShape())
       return std::nullopt;
 
     auto elementSize = getTypeNumBytes(options, tensorType.getElementType());
     if (!elementSize)
       return std::nullopt;
 
     int64_t size = *elementSize;

 /// Note that this is mainly for lowering constant tensors. In SPIR-V one can
 /// create composite constants with OpConstantComposite to embed relative large
 /// constant values and use OpCompositeExtract and OpCompositeInsert to
 /// manipulate, like what we do for vectors.
 static Type convertTensorType(const spirv::TargetEnv &targetEnv,
                               const SPIRVConversionOptions &options,
                               TensorType type) {
   // TODO: Handle dynamic shapes.
-  if (!type.hasStaticShape()) {
+  auto rankedTensorType = dyn_cast<RankedTensorType>(type);
+  if (!rankedTensorType || !rankedTensorType.hasStaticShape()) {
     LLVM_DEBUG(llvm::dbgs()
                << type << " illegal: dynamic shape unimplemented\n");
     return nullptr;
   }
 
   type = cast<TensorType>(convertIndexElementType(type, options));
   auto scalarType = dyn_cast_or_null<spirv::ScalarType>(type.getElementType());
   if (!scalarType) {
Value mlir::spirv::getVulkanElementPtr(SPIRVTypeConverter &typeConverter,
                                        MemRefType baseType, Value basePtr,
                                        ValueRange indices, Location loc,
                                        OpBuilder &builder) {
   // Get base and offset of the MemRefType and verify they are static.
 
   int64_t offset;
   SmallVector<int64_t, 4> strides;
   if (failed(getStridesAndOffset(baseType, strides, offset)) ||
-      llvm::is_contained(strides, ShapedType::kDynamic) ||
-      ShapedType::isDynamic(offset)) {
+      llvm::is_contained(strides, RankedShapedType::kDynamic) ||
+      RankedShapedType::isDynamic(offset)) {
     return nullptr;
   }
 
   auto indexType = typeConverter.getIndexType();
 
   SmallVector<Value, 2> linearizedIndices;
   auto zero = spirv::ConstantOp::getZero(indexType, loc, builder);
 
Value mlir::spirv::getOpenCLElementPtr(SPIRVTypeConverter &typeConverter,
                                        MemRefType baseType, Value basePtr,
                                        ValueRange indices, Location loc,
                                        OpBuilder &builder) {
   // Get base and offset of the MemRefType and verify they are static.
 
   int64_t offset;
   SmallVector<int64_t, 4> strides;
   if (failed(getStridesAndOffset(baseType, strides, offset)) ||
-      llvm::is_contained(strides, ShapedType::kDynamic) ||
-      ShapedType::isDynamic(offset)) {
+      llvm::is_contained(strides, RankedShapedType::kDynamic) ||
+      RankedShapedType::isDynamic(offset)) {
     return nullptr;
   }
 
   auto indexType = typeConverter.getIndexType();
 
   SmallVector<Value, 2> linearizedIndices;
   Value linearIndex;
   if (baseType.getRank() == 0) {

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

 bool shape::isExtentTensorType(Type type) {
   auto ranked = type.dyn_cast<RankedTensorType>();
   return ranked && ranked.getRank() == 1 && ranked.getElementType().isIndex();
 }
 
 LogicalResult shape::getShapeVec(Value input,
                                  SmallVectorImpl<int64_t> &shapeValues) {
   if (auto inputOp = input.getDefiningOp<ShapeOfOp>()) {
-    auto type = inputOp.getArg().getType().cast<ShapedType>();
-    if (!type.hasRank())
+    auto type = inputOp.getArg().getType().dyn_cast<RankedShapedType>();
+    if (!type)
       return failure();
     llvm::append_range(shapeValues, type.getShape());
     return success();
   }
   DenseIntElementsAttr attr;
   if (matchPattern(input, m_Constant(&attr))) {
     llvm::append_range(shapeValues, attr.getValues<int64_t>());
     return success();
if (auto constSizeOp = getIndex().getDefiningOp<ConstSizeOp>())
     return constSizeOp.getValue().getLimitedValue();
   if (auto constantOp = getIndex().getDefiningOp<arith::ConstantOp>())
     return constantOp.getValue().cast<IntegerAttr>().getInt();
   return std::nullopt;
 }
 
 OpFoldResult DimOp::fold(FoldAdaptor adaptor) {
   Type valType = getValue().getType();
-  auto valShapedType = valType.dyn_cast<ShapedType>();
-  if (!valShapedType || !valShapedType.hasRank())
+  auto valShapedType = valType.dyn_cast<RankedShapedType>();
+  if (!valShapedType)
     return nullptr;
   std::optional<int64_t> index = getConstantIndex();
   if (!index.has_value())
     return nullptr;
   if (index.value() >= valShapedType.getRank())
     return nullptr;
   auto extent = valShapedType.getDimSize(*index);
-  if (ShapedType::isDynamic(extent))
+  if (RankedShapedType::isDynamic(extent))
     return nullptr;
   return IntegerAttr::get(IndexType::get(getContext()), extent);
 }
 
 LogicalResult mlir::shape::DimOp::inferReturnTypes(
     MLIRContext *context, std::optional<Location> location, ValueRange operands,
     DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   DimOpAdaptor dimOp(operands);
   inferredReturnTypes.assign({dimOp.getIndex().getType()});
   return success();
 }
 
 bool mlir::shape::DimOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   return eachHasOnlyOneOfTypes<SizeType, IndexType>(l, r);
 }
 
 LogicalResult mlir::shape::DimOp::verify() {
-  auto st = getValue().getType().cast<ShapedType>();
-  if (!st.hasRank())
+  auto st = getValue().getType().dyn_cast<RankedShapedType>();
+  if (!st)
     return success();
   if (auto index = getConstantIndex()) {
     if (*index < 0 || *index >= st.getRank())
       return emitOpError("index is out of range");
   }
   return success();
 }
 
if (l.isa<SizeType>()) {
       // Handle shapes, propagate error type if present.
       if (isShapeType(r))
         acc = l;
       else
         return emitOptionalError(location, "requires all sizes or shapes");
     } else if (isExtentTensorType(l)) {
       auto rank1 = l.cast<RankedTensorType>().getShape()[0];
       auto rank2 = r.cast<RankedTensorType>().getShape()[0];
-      if (ShapedType::isDynamic(rank1))
+      if (RankedShapedType::isDynamic(rank1))
         acc = l;
-      else if (ShapedType::isDynamic(rank2))
+      else if (RankedShapedType::isDynamic(rank2))
         acc = r;
       else if (rank1 != rank2)
         return emitOptionalError(location, "unequal shape cardinality");
       else
         acc = l;
     }
   }
   inferredReturnTypes.assign({acc});

 
 LogicalResult shape::MulOp::verify() { return verifySizeOrIndexOp(*this); }
 
 //===----------------------------------------------------------------------===//
 // ShapeOfOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult ShapeOfOp::fold(FoldAdaptor) {
-  auto type = getOperand().getType().dyn_cast<ShapedType>();
+  auto type = getOperand().getType().dyn_cast<RankedShapedType>();
   if (!type || !type.hasStaticShape())
     return nullptr;
   Builder builder(getContext());
   return builder.getIndexTensorAttr(type.getShape());
 }
 
 namespace {
 struct ShapeOfWithTensor : public OpRewritePattern<shape::ShapeOfOp> {

 
 LogicalResult mlir::shape::ShapeOfOp::inferReturnTypes(
     MLIRContext *context, std::optional<Location> location, ValueRange operands,
     DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<ValueShapeType>())
     inferredReturnTypes.assign({ShapeType::get(context)});
   else {
-    auto shapedTy = operands[0].getType().cast<ShapedType>();
-    int64_t rank =
-        shapedTy.hasRank() ? shapedTy.getRank() : ShapedType::kDynamic;
+    auto shapedTy = operands[0].getType().dyn_cast<RankedShapedType>();
+    int64_t rank = shapedTy ? shapedTy.getRank() : RankedShapedType::kDynamic;
     Type indexTy = IndexType::get(context);
     Type extentTensorTy = RankedTensorType::get({rank}, indexTy);
     inferredReturnTypes.assign({extentTensorTy});
   }
   return success();
 }
 
 bool mlir::shape::ShapeOfOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {

mlir/lib/Dialect/Shape/IR/ShapeCanonicalization.td

 include "mlir/IR/PatternBase.td"
 include "mlir/Dialect/Shape/IR/ShapeOps.td"
 include "mlir/Dialect/Tensor/IR/TensorOps.td"
 
 def AllInputShapesEq : Constraint<CPred< [{
   llvm::all_equal($0)
 }]>>;
 
 def HasSingleElement : Constraint<CPred< [{
   $0.size() == 1
 }]>>;
 
 def HasStaticShape : Constraint<CPred< [{
-  $0.getType().dyn_cast<ShapedType>().hasStaticShape()
+  $0.getType().isa<RankedShapedType>()
+      && $0.getType().cast<RankedShapedType>().hasStaticShape()
 }]>>;
 
 // Helper that takes the first element of a range.
 def TakeFront : NativeCodeCall<"$0.front()">;
 
 // Canonicalization patterns.
 
 def AssumingAllOneOp : Pat<(Shape_AssumingAllOp $args),

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

if (valuesTp.getRank() != 1)
     return op->emitError("values must have rank 1");
   if (requiresStaticShape && !valuesTp.hasStaticShape())
     return op->emitError("values must have static shape");
   if (valuesTp.getElementType() != tensorTp.getElementType())
     return op->emitError("input/output element-types don't match");
 
   const auto valuesNSE = valuesTp.getShape()[0];
   const auto coordsNSE = coordinatesTp.getShape()[0];
-  if (!ShapedType::isDynamic(valuesNSE) && !ShapedType::isDynamic(coordsNSE) &&
-      valuesNSE != coordsNSE)
+  if (!RankedShapedType::isDynamic(valuesNSE) &&
+      !RankedShapedType::isDynamic(coordsNSE) && valuesNSE != coordsNSE)
     return op->emitError("values/coordinates number-of-elements don't match");
 
   // NOTE: We use `getLvlRank` because the `coordinatesTp` is for
   // level-coordinates (cf., the op documentation).
   const DynSize coordsRank = coordinatesTp.getShape()[1];
   const Level tensorRank = tensorTp.getLvlRank();
   // FIXME: replace the `operator!=` with our backported `safelyNE`.
-  if (!ShapedType::isDynamic(coordsRank) &&
+  if (!RankedShapedType::isDynamic(coordsRank) &&
       coordsRank != static_cast<DynSize>(tensorRank))
     return op->emitError("input/output level-ranks don't match");
 
   return success();
 }
 
 LogicalResult PackOp::verify() {
   const auto valuesTp = getRankedTensorType(getValues());
if (auto tp2 = getDest().getType().dyn_cast<RankedTensorType>()) {
         return emitError("cannot convert to a sparse tensor slice");
 
       auto shape1 = tp1.getShape();
       auto shape2 = tp2.getShape();
       // Accept size matches between the source and the destination type
       // (e.g. 10 vs. 10, 10 vs. ?, or ? vs. ?), but reject direct mismatches or
       // matches that would need a runtime assert (e.g. 10 vs. 20 or ? vs. 10).
       for (Dimension d = 0, dimRank = tp1.getRank(); d < dimRank; d++)
-        if (shape1[d] != shape2[d] && shape2[d] != ShapedType::kDynamic)
+        if (shape1[d] != shape2[d] && shape2[d] != RankedShapedType::kDynamic)
           return emitError("unexpected conversion mismatch in dimension ") << d;
       return success();
     }
   }
   return emitError("unexpected type in convert");
 }
 
 OpFoldResult ConvertOp::fold(FoldAdaptor adaptor) {
if (srcDimRank != dimRank)
           llvm::formatv("Input tensor ${0} has a different rank (rank={1}) "
                         "from the output tensor (rank={2}).",
                         i, srcDimRank, dimRank));
   }
 
   for (Dimension d = 0; d < dimRank; d++) {
     const DynSize dstSh = dstTp.getDimShape()[d];
     if (d == concatDim) {
-      if (!ShapedType::isDynamic(dstSh)) {
+      if (!RankedShapedType::isDynamic(dstSh)) {
         // If we reach here, then all inputs have static shapes.  So we
         // can use `getDimShape()[d]` instead of `*getDynamicDimSize(d)`
         // to avoid redundant assertions in the loop.
         StaticSize sumSz = 0;
         for (const auto src : getInputs())
           sumSz += getSparseTensorType(src).getDimShape()[d];
         // If all dimension are statically known, the sum of all the input
         // dimensions should be equal to the output dimension.
         if (sumSz != dstSh)
           return emitError(
               "The concatenation dimension of the output tensor should be the "
               "sum of all the concatenation dimensions of the input tensors.");
       }
     } else {
       DynSize prev = dstSh;
       for (const auto src : getInputs()) {
         const auto sh = getSparseTensorType(src).getDimShape()[d];
-        if (!ShapedType::isDynamic(prev) && sh != prev)
+        if (!RankedShapedType::isDynamic(prev) && sh != prev)
           return emitError("All dimensions (expect for the concatenating one) "
                            "should be equal.");
         prev = sh;
       }
     }
   }
 
   return success();
LogicalResult SortOp::verify() {
   Type xtp = getMemRefType(getXs().front()).getElementType();
   auto checkTypes = [&](ValueRange operands,
                         bool checkEleType = true) -> LogicalResult {
     for (Value opnd : operands) {
       auto mtp = getMemRefType(opnd);
       const DynSize sh = mtp.getShape()[0];
       // We can't check the size of dynamic dimension at compile-time, but all
       // xs and ys should have a dimension not less than n at runtime.
-      if (n && !ShapedType::isDynamic(sh) && sh < n.value())
+      if (n && !RankedShapedType::isDynamic(sh) && sh < n.value())
         return emitError(llvm::formatv("xs and ys need to have a dimension >= n"
                                        ": {0} < {1}",
                                        sh, n.value()));
 
       if (checkEleType && xtp != mtp.getElementType())
         return emitError("mismatch xs element types");
     }
     return success();
if (auto nyAttr = getNyAttr()) {
     ny = nyAttr.getInt();
   }
 
   // FIXME: update the types of variables used in expressions bassed as
   // the `minSize` argument, to avoid implicit casting at the callsites
   // of this lambda.
   const auto checkDim = [&](Value v, StaticSize minSize, const char *message) {
     const DynSize sh = getMemRefType(v).getShape()[0];
-    if (!ShapedType::isDynamic(sh) && sh < minSize)
+    if (!RankedShapedType::isDynamic(sh) && sh < minSize)
       emitError(llvm::formatv("{0} got {1} < {2}", message, sh, minSize));
   };
 
   checkDim(getXy(), n * (nx + ny), "Expected dimension(xy) >= n * (nx + ny)");
 
   for (Value opnd : getYs()) {
     checkDim(opnd, n, "Expected dimension(y) >= n");
   }

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

 void sizesFromSrc(OpBuilder &builder, SmallVectorImpl<Value> &sizes,
                   Location loc, Value src);
 
 /// Generates a 1D MemRefType with a dynamic size. When withLayout is set, the
 /// returned memref has a layout has unknown strides and offsets. Otherwise,
 /// a memref with a standard unit stride zero offset layout is returned.
 inline MemRefType get1DMemRefType(Type etp, bool withLayout) {
   auto layout = withLayout ? StridedLayoutAttr::StridedLayoutAttr::get(
-                                 etp.getContext(), ShapedType::kDynamic,
-                                 {ShapedType::kDynamic})
+                                 etp.getContext(), RankedShapedType::kDynamic,
+                                 {RankedShapedType::kDynamic})
                            : StridedLayoutAttr();
-  return MemRefType::get(ShapedType::kDynamic, etp, layout);
+  return MemRefType::get(RankedShapedType::kDynamic, etp, layout);
 }
 
 /// Scans to top of generated loop.
 Operation *getTop(Operation *op);
 
 /// Iterate over a sparse constant, generates constantOp for value
 /// and coordinates.  E.g.,
 /// sparse<[ [0], [28], [31] ],

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

for (unsigned i = 0, size = srcShape.size(); i < size; i++) {
     const auto &map = reassociation[i];
     auto srcDim = srcShape[i];
     // Iterate through dimensions expanded from the i-th dimension.
     for (unsigned j = start; j < start + map.size(); j++) {
       // There can be only one dynamic sized dimension among dimensions
       // expanded from the i-th dimension in srcShape.
       // For example, if srcDim = 8, then the expanded shape could be <2x?x2>,
       // but not <2x?x?>.
-      if (staticDstShape[j] == ShapedType::kDynamic) {
+      if (staticDstShape[j] == RankedShapedType::kDynamic) {
         // The expanded dimension has dynamic size. We compute the dimension
         // by dividing srcDim by the product of the static dimensions.
         StaticSize product = 1;
         for (unsigned k = start; k < start + map.size(); k++) {
-          if (staticDstShape[k] != ShapedType::kDynamic) {
+          if (staticDstShape[k] != RankedShapedType::kDynamic) {
             product *= staticDstShape[k];
           }
         }
         // Compute the dynamic dimension size.
         Value productVal = constantIndex(builder, loc, product);
         Value dynamicSize =
             builder.create<arith::DivUIOp>(loc, srcDim, productVal);
         dstShape.push_back(dynamicSize);
if (staticShape) {
     auto memTp = MemRefType::get({sz}, tp);
     return builder.create<memref::AllocaOp>(loc, memTp);
   }
   return genAlloca(builder, loc, constantIndex(builder, loc, sz), tp);
 }
 
 Value mlir::sparse_tensor::genAlloca(OpBuilder &builder, Location loc, Value sz,
                                      Type tp) {
-  auto memTp = MemRefType::get({ShapedType::kDynamic}, tp);
+  auto memTp = MemRefType::get({RankedShapedType::kDynamic}, tp);
   return builder.create<memref::AllocaOp>(loc, memTp, ValueRange{sz});
 }
 
 Value mlir::sparse_tensor::genAllocaScalar(OpBuilder &builder, Location loc,
                                            Type tp) {
   return builder.create<memref::AllocaOp>(loc, MemRefType::get({}, tp));
 }
 

 Value mlir::sparse_tensor::allocDenseTensor(OpBuilder &builder, Location loc,
                                             RankedTensorType tensorTp,
                                             ValueRange sizes) {
   Type elemTp = tensorTp.getElementType();
   auto shape = tensorTp.getShape();
   auto memTp = MemRefType::get(shape, elemTp);
   SmallVector<Value> dynamicSizes;
   for (unsigned i = 0, rank = tensorTp.getRank(); i < rank; i++) {
-    if (shape[i] == ShapedType::kDynamic)
+    if (shape[i] == RankedShapedType::kDynamic)
       dynamicSizes.push_back(sizes[i]);
   }
   Value mem = builder.create<memref::AllocOp>(loc, memTp, dynamicSizes);
   Value zero = constantZero(builder, loc, elemTp);
   builder.create<linalg::FillOp>(loc, ValueRange{zero}, ValueRange{mem});
   return mem;
 }
 

 
 SmallVector<Value> sparse_tensor::loadAll(OpBuilder &builder, Location loc,
                                           size_t size, Value mem,
                                           size_t offsetIdx, Value offsetVal) {
 #ifndef NDEBUG
   const auto memTp = mem.getType().cast<MemRefType>();
   assert(memTp.getRank() == 1);
   const DynSize memSh = memTp.getDimSize(0);
-  assert(ShapedType::isDynamic(memSh) || memSh >= static_cast<DynSize>(size));
+  assert(RankedShapedType::isDynamic(memSh) ||
+         memSh >= static_cast<DynSize>(size));
   assert(offsetIdx == 0 || offsetIdx < size);
 #endif // NDEBUG
   SmallVector<Value> vs;
   vs.reserve(size);
   for (unsigned i = 0; i < size; i++) {
     Value v = builder.create<memref::LoadOp>(loc, mem,
                                              constantIndex(builder, loc, i));
     if (i == offsetIdx && offsetVal)
       v = builder.create<arith::AddIOp>(loc, v, offsetVal);
     vs.push_back(v);
   }
   return vs;
 }
 
 void sparse_tensor::storeAll(OpBuilder &builder, Location loc, Value mem,
                              ValueRange vs, size_t offsetIdx, Value offsetVal) {
 #ifndef NDEBUG
   const size_t vsize = vs.size();
   const auto memTp = mem.getType().cast<MemRefType>();
   assert(memTp.getRank() == 1);
   const DynSize memSh = memTp.getDimSize(0);
-  assert(ShapedType::isDynamic(memSh) || memSh >= static_cast<DynSize>(vsize));
+  assert(RankedShapedType::isDynamic(memSh) ||
+         memSh >= static_cast<DynSize>(vsize));
   assert(offsetIdx == 0 || offsetIdx < vsize);
 #endif // NDEBUG
   for (const auto &v : llvm::enumerate(vs)) {
     const Value w =
         (offsetIdx == v.index() && offsetVal)
             ? builder.create<arith::AddIOp>(loc, v.value(), offsetVal)
             : v.value();
     builder.create<memref::StoreOp>(loc, w, mem,
Value sparse_tensor::reshapeValuesToLevels(OpBuilder &builder, Location loc,
   storeAll(builder, loc, lvlCoords, lvlSizes);
   // The memref ReshapeOp requires the sizes buffer to have a static
   // shape.
   const auto iTp = builder.getIndexType();
   const SmallVector<DynSize, 1> lvlSizesShape{static_cast<DynSize>(lvlRank)};
   const auto lvlSizesTp = MemRefType::get(lvlSizesShape, iTp);
   lvlCoords = builder.create<memref::CastOp>(loc, lvlSizesTp, lvlCoords);
   // Finally, create the ReshapeOp.
-  const SmallVector<DynSize> resShape(lvlRank, ShapedType::kDynamic);
+  const SmallVector<DynSize> resShape(lvlRank, RankedShapedType::kDynamic);
   const Type elemTp = getMemRefType(valuesBuffer).getElementType();
   const auto resTp = MemRefType::get(resShape, elemTp);
   return builder.create<memref::ReshapeOp>(loc, resTp, valuesBuffer, lvlCoords);
 }
 
 Value sparse_tensor::genToPositions(OpBuilder &builder, Location loc,
                                     Value tensor, Level lvl) {
   const auto srcTp = getSparseTensorType(tensor);

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

LogicalResult matchAndRewriteSortOp(OpTy op, ValueRange xys, uint64_t nx,
   Location loc = op.getLoc();
   SmallVector<Value> operands{constantIndex(rewriter, loc, 0), op.getN()};
 
   // Convert `values` to have dynamic shape and append them to `operands`.
   for (Value v : xys) {
     auto mtp = getMemRefType(v);
     if (!mtp.isDynamicDim(0)) {
       auto newMtp =
-          MemRefType::get({ShapedType::kDynamic}, mtp.getElementType());
+          MemRefType::get({RankedShapedType::kDynamic}, mtp.getElementType());
       v = rewriter.create<memref::CastOp>(loc, newMtp, v);
     }
     operands.push_back(v);
   }
 
   auto insertPoint = op->template getParentOfType<func::FuncOp>();
   if (!insertPoint)
     return failure();
LogicalResult matchAndRewrite(PushBackOp op,
     bool nIsOne = (nValue && nValue.value() == 1);
 
     if (!op.getInbounds()) {
       Value cond = rewriter.create<arith::CmpIOp>(
           loc, arith::CmpIPredicate::ugt, newSize, capacity);
 
       Value c2 = constantIndex(rewriter, loc, 2);
       auto bufferType =
-          MemRefType::get({ShapedType::kDynamic}, value.getType());
+          MemRefType::get({RankedShapedType::kDynamic}, value.getType());
       scf::IfOp ifOp = rewriter.create<scf::IfOp>(loc, bufferType, cond,
                                                   /*else=*/true);
       // True branch.
       rewriter.setInsertionPointToStart(&ifOp.getThenRegion().front());
       if (nIsOne) {
         capacity = rewriter.create<arith::MulIOp>(loc, capacity, c2);
       } else {
         // Use a do-while loop to calculate the new capacity as follows:

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

static void createAllocFields(OpBuilder &builder, Location loc,
   // Build original sizes.
   assert((dynSizes.size() == static_cast<size_t>(stt.getNumDynamicDims())) &&
          "Got wrong number of dynamic sizes");
   const Dimension dimRank = stt.getDimRank();
   SmallVector<Value> dimSizes;
   dimSizes.reserve(dimRank);
   unsigned i = 0; // cumulative index into `dynSizes`.
   for (const DynSize sh : stt.getDimShape())
-    dimSizes.push_back(ShapedType::isDynamic(sh)
+    dimSizes.push_back(RankedShapedType::isDynamic(sh)
                            ? dynSizes[i++]
                            : constantIndex(builder, loc, sh));
 
   // Set up some heuristic sizes. We try to set the initial
   // size based on available information. Otherwise we just
   // initialize a few elements to start the reallocation chain.
   // TODO: refine this
   Value posHeuristic, crdHeuristic, valHeuristic;
matchAndRewrite(ExpandOp op, OpAdaptor adaptor,
     // Determine the size for access expansion (always the innermost stored
     // level size, translated back to original dimension). Note that we
     // recursively rewrite the new DimOp on the **original** tensor.
     // FIXME: `toOrigDim` is deprecated.
     const Dimension innerDim = toOrigDim(srcType, srcType.getLvlRank() - 1);
     const auto sz = sizeFromTensorAtDim(rewriter, loc, desc, innerDim);
     // Generate a memref for `sz` elements of type `t`.
     const auto genAlloc = [&](Type t) {
-      const auto memTp = MemRefType::get({ShapedType::kDynamic}, t);
+      const auto memTp = MemRefType::get({RankedShapedType::kDynamic}, t);
       return rewriter.create<memref::AllocOp>(loc, memTp, ValueRange{sz});
     };
     // Allocate temporary buffers for values/filled-switch and added.
     // We do not use stack buffers for this, since the expanded size may
     // be rather large (as it envelops a single expanded dense dimension).
     Value values = genAlloc(eltType);
     Value filled = genAlloc(boolType);
     Value added = genAlloc(idxType);
foreachFieldAndTypeInSparseTensor(
           return true;
         });
 
     MutSparseTensorDescriptor desc(stt, fields);
     auto noe = linalg::createOrFoldDimOp(rewriter, loc, op.getValues(), 0);
     for (Level lvl = 0, lvlRank = stt.getLvlRank(); lvl < lvlRank; lvl++) {
       // FIXME: dim/lvl confusion!
       const auto sh = stt.getDimShape()[lvl];
-      assert(!ShapedType::isDynamic(sh));
+      assert(!RankedShapedType::isDynamic(sh));
       desc.setLvlSize(rewriter, loc, lvl, constantIndex(rewriter, loc, sh));
       if (lvl == 0)
         desc.setPosMemSize(rewriter, loc, lvl, constantIndex(rewriter, loc, 2));
 
       desc.setCrdMemSize(rewriter, loc, lvl, noe);
     }
     desc.setValMemSize(rewriter, loc, noe);
 
matchAndRewrite(NewOp op, OpAdaptor adaptor,
     if (dstTp.hasDynamicDimShape()) {
       // FIXME: call `getSparseTensorReaderDimSizes` instead, because
       // `copySparseTensorReaderDimSizes` copies the memref over,
       // instead of just accessing the reader's memory directly.
       Value dimSizes = genAlloca(rewriter, loc, dimRank, indexTp);
       createFuncCall(rewriter, loc, "copySparseTensorReaderDimSizes", {},
                      {reader, dimSizes}, EmitCInterface::On);
       for (const auto &d : llvm::enumerate(dstTp.getDimShape()))
-        if (ShapedType::isDynamic(d.value()))
+        if (RankedShapedType::isDynamic(d.value()))
           dynSizes.push_back(rewriter.create<memref::LoadOp>(
               loc, dimSizes, constantIndex(rewriter, loc, d.index())));
     }
 
     Value nse = createFuncCall(rewriter, loc, "getSparseTensorReaderNSE",
                                {indexTp}, {reader}, EmitCInterface::Off)
                     .getResult(0);
     // Construct allocation for each field.

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

 
 /// Populates the array with the dimension-shape of the given
 /// `SparseTensorType`, where dynamic sizes are represented by zero.
 static void fillDimShape(OpBuilder &builder, Location loc, SparseTensorType stt,
                          SmallVectorImpl<Value> &out) {
   out.clear();
   out.reserve(stt.getDimRank());
   for (const DynSize sh : stt.getDimShape()) {
-    const auto s = ShapedType::isDynamic(sh) ? 0 : sh;
+    const auto s = RankedShapedType::isDynamic(sh) ? 0 : sh;
     out.push_back(constantIndex(builder, loc, s));
   }
 }
 
 /// Returns an array with the dimension-shape of the given `SparseTensorType`,
 /// where dynamic sizes are represented by zero.
 static SmallVector<Value> getDimShape(OpBuilder &builder, Location loc,
                                       SparseTensorType stt) {
static void concatDimSizesFromInputs(OpBuilder &builder, Location loc,
   }
 }
 
 /// Generates an uninitialized buffer of the given size and type,
 /// but returns it as type `memref<? x $tp>` (rather than as type
 /// `memref<$sz x $tp>`). Unlike temporary buffers on the stack,
 /// this buffer must be explicitly deallocated by client.
 static Value genAlloc(RewriterBase &rewriter, Location loc, Value sz, Type tp) {
-  auto memTp = MemRefType::get({ShapedType::kDynamic}, tp);
+  auto memTp = MemRefType::get({RankedShapedType::kDynamic}, tp);
   return rewriter.create<memref::AllocOp>(loc, memTp, ValueRange{sz});
 }
 
 /// Generates a temporary buffer for the level-types of the given encoding.
 static Value genLvlTypesBuffer(OpBuilder &builder, Location loc,
                                SparseTensorType stt) {
   SmallVector<Value> lvlTypes;
   lvlTypes.reserve(stt.getLvlRank());
matchAndRewrite(NewOp op, OpAdaptor adaptor,
     // TODO: For now we're still assuming `dim2lvl` is a permutation.
     // But since we're computing lvlSizes here (rather than in the runtime),
     // we can easily generalize that simply by adjusting this code.
     //
     // FIXME: reduce redundancy vs `NewCallParams::genBuffers`.
     Value dimSizesBuffer;
     if (stt.hasDynamicDimShape()) {
       Type indexTp = rewriter.getIndexType();
-      auto memTp = MemRefType::get({ShapedType::kDynamic}, indexTp);
+      auto memTp = MemRefType::get({RankedShapedType::kDynamic}, indexTp);
       dimSizesBuffer =
           createFuncCall(rewriter, loc, "getSparseTensorReaderDimSizes", memTp,
                          reader, EmitCInterface::On)
               .getResult(0);
     }
     Value lvlSizesBuffer;
     Value lvl2dimBuffer;
     Value dim2lvlBuffer;

 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
   matchAndRewrite(NumberOfEntriesOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op.getLoc();
     // Query values array size for the actually stored values size.
     Type eltType = op.getTensor().getType().cast<ShapedType>().getElementType();
-    auto resTp = MemRefType::get({ShapedType::kDynamic}, eltType);
+    auto resTp = MemRefType::get({RankedShapedType::kDynamic}, eltType);
     Value values = genValuesCall(rewriter, loc, resTp, adaptor.getOperands());
     rewriter.replaceOpWithNewOp<memref::DimOp>(op, values,
                                                constantIndex(rewriter, loc, 0));
     return success();
   }
 };
 
 /// Sparse conversion rule for tensor rematerialization.
if (dstTp.hasEncoding()) {
       // Start a new COO or an initialized annotated all dense sparse tensor.
       dst = params.genBuffers(dstTp, dimSizes)
                 .genNewCall(allDense ? Action::kEmpty : Action::kEmptyCOO);
       dstDimCoords = genAlloca(rewriter, loc, dimRank, rewriter.getIndexType());
       if (allDense) {
         dstTensor = dst;
         // Get the values buffer for the sparse tensor and reshape it to the
         // corresponding dense tensor shape.
-        dst = genValuesCall(rewriter, loc,
-                            MemRefType::get({ShapedType::kDynamic}, elemTp),
-                            {dst});
+        dst = genValuesCall(
+            rewriter, loc,
+            MemRefType::get({RankedShapedType::kDynamic}, elemTp), {dst});
         // Pass the `dstDimCoords` buffer for `reshapeValuesToLevels`
         // to reuse for storing level-sizes (yes, "level-sizes").
         // This is safe to do because `dstTp` is a dense-tensor type,
         // and therefore lvlRank == dimRank.
         dst = reshapeValuesToLevels(rewriter, loc, dstEnc, dimSizes, dst,
                                     dstDimCoords);
       } else {
         dstPerm = params.getDim2LvlMap();

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

if (auto arg = yieldOp.getOperand(0).dyn_cast<BlockArgument>()) {
     }
   }
   return isZeroValue(yieldOp.getOperand(0));
 }
 
 /// Populates given sizes array from type (for static sizes) and from
 /// the tensor (for dynamic sizes).
 static void sizesForTensor(OpBuilder &builder, SmallVectorImpl<Value> &sizes,
-                           Location loc, ShapedType stp, Value tensor) {
+                           Location loc, RankedShapedType stp, Value tensor) {
   for (const auto &d : enumerate(stp.getShape())) {
     Value dim;
-    if (d.value() == ShapedType::kDynamic)
+    if (d.value() == RankedShapedType::kDynamic)
       dim = builder.create<tensor::DimOp>(loc, tensor, d.index());
     else
       dim = constantIndex(builder, loc, d.value());
     sizes.push_back(dim);
   }
 }
 
 // TODO: The dim level property of the COO type relies on input tensors, the

 
 /// Collects the dynamic dimension sizes for `tp` with the assumption that
 /// `sizes` are the dimension sizes for the type. Stores the dynamic dimension
 /// sizes to dynSizes.
 static void getDynamicSizes(RankedTensorType tp,
                             const SmallVectorImpl<Value> &sizes,
                             SmallVectorImpl<Value> &dynSizes) {
   for (const auto &d : enumerate(tp.getShape())) {
-    if (d.value() == ShapedType::kDynamic)
+    if (d.value() == RankedShapedType::kDynamic)
       dynSizes.push_back(sizes[d.index()]);
   }
 }
 
 static LogicalResult genForeachOnSparseConstant(ForeachOp op,
                                                 RewriterBase &rewriter,
                                                 SparseElementsAttr attr) {
   auto loc = op.getLoc();
static LogicalResult genForeachOnSparseConstant(ForeachOp op,
   rewriter.replaceOp(op, reduc);
   return success();
 }
 
 /// Populates the given sizes array for concatenation from types (for static
 /// sizes) and from the source tensors (for dynamic sizes).
 static void concatSizesFromInputs(OpBuilder &builder,
                                   SmallVectorImpl<Value> &sizes, Location loc,
-                                  ShapedType dstTp, ValueRange srcs,
+                                  RankedShapedType dstTp, ValueRange srcs,
                                   unsigned dim) {
   auto dstShape = dstTp.getShape();
   sizesFromSrc(builder, sizes, loc, srcs[0]);
 
   // Sum up on the `dim` if the dimension is dynamic.
-  if (dstShape[dim] != ShapedType::kDynamic) {
+  if (dstShape[dim] != RankedShapedType::kDynamic) {
     // Faithfully take the static size.
     sizes[dim] = constantIndex(builder, loc, dstShape[dim]);
   } else {
     // Else, compute the shape dynamically.
     for (const auto &src : srcs.drop_front()) {
       Value srcSz = linalg::createOrFoldDimOp(builder, loc, src, dim);
       // Sum up all the sizes.
       sizes[dim] = builder.create<arith::AddIOp>(loc, sizes[dim], srcSz);
LogicalResult matchAndRewrite(ReshapeOp op,
     if (dstTp.hasStaticDimShape()) {
       for (Dimension d : dstTp.getDimShape())
         dstSizes.push_back(constantIndex(rewriter, loc, d));
     } else {
       ArrayRef<DynSize> dstShape = dstTp.getDimShape();
       genReshapeDstShape(rewriter, loc, dstSizes, srcSizes, dstShape,
                          op.getReassociationIndices());
       for (auto [idx, shape] : llvm::enumerate(dstShape)) {
-        if (shape == ShapedType::kDynamic)
+        if (shape == RankedShapedType::kDynamic)
           dstDynSizes.push_back(dstSizes[idx]);
       }
     }
     Value nnz = rewriter.create<NumberOfEntriesOp>(loc, srcTensor);
     // Only need a unordered COO buffer if input and output are not sorted
     // in the same way.
     Type bufferTp =
         srcTp.isAllOrdered() && srcTp.isIdentity() && dstTp.isIdentity()

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

void sparse_tensor::foreachFieldAndTypeInSparseTensor(
   assert(stt.hasEncoding());
   // Construct the basic types.
   const Type crdType = stt.getCrdType();
   const Type posType = stt.getPosType();
   const Type eltType = stt.getElementType();
 
   const Type metaDataType = StorageSpecifierType::get(stt.getEncoding());
   // memref<? x pos>  positions
-  const Type posMemType = MemRefType::get({ShapedType::kDynamic}, posType);
+  const Type posMemType =
+      MemRefType::get({RankedShapedType::kDynamic}, posType);
   // memref<? x crd>  coordinates
-  const Type crdMemType = MemRefType::get({ShapedType::kDynamic}, crdType);
+  const Type crdMemType =
+      MemRefType::get({RankedShapedType::kDynamic}, crdType);
   // memref<? x eltType> values
-  const Type valMemType = MemRefType::get({ShapedType::kDynamic}, eltType);
+  const Type valMemType =
+      MemRefType::get({RankedShapedType::kDynamic}, eltType);
 
   foreachFieldInSparseTensor(
       stt.getEncoding(),
       [metaDataType, posMemType, crdMemType, valMemType,
        callback](FieldIndex fieldIdx, SparseTensorFieldKind fieldKind,
                  Level lvl, DimLevelType dlt) -> bool {
         switch (fieldKind) {
         case SparseTensorFieldKind::StorageSpec:

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

static void genExpand(CodegenEnv &env, OpBuilder &builder, LoopOrd at,
   // Generate start or end of an expanded access pattern. Note that because
   // an expension does not rely on the ongoing contents of the sparse storage
   // scheme, we can use the original tensor as incoming SSA value (which
   // simplifies codegen a bit). If expansion on the actual contents is ever
   // needed, we will need to use the SSA value in the insertion chain instead.
   Value tensor = lhs->get();
   Location loc = op.getLoc();
   if (atStart) {
-    auto dynShape = {ShapedType::kDynamic};
+    auto dynShape = {RankedShapedType::kDynamic};
     Type etp = tensor.getType().cast<ShapedType>().getElementType();
     Type t1 = MemRefType::get(dynShape, etp);
     Type t2 = MemRefType::get(dynShape, builder.getI1Type());
     Type t3 = MemRefType::get(dynShape, builder.getIndexType());
     Type t4 = builder.getIndexType();
     auto r = builder.create<ExpandOp>(loc, TypeRange({t1, t2, t3, t4}), tensor);
     assert(r.getNumResults() == 4);
     env.startExpand(r.getResult(0), r.getResult(1), r.getResult(2),

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

 
 /// For reshape op compute the shape at dimension `dimIndex` of the output in
 /// terms of shape of the `src`, when the reshape op is a collapsing
 /// operation. It is the product of the shape of the collapsed dimensions of the
 /// `src`.
 static OpFoldResult getCollapsedOutputDimFromInputShape(
     OpBuilder &builder, Location loc, int64_t dimIndex, Value src,
     ArrayRef<int64_t> dstStaticShape, ArrayRef<AffineMap> reassociationMap) {
-  if (!ShapedType::isDynamic(dstStaticShape[dimIndex])) {
+  if (!RankedShapedType::isDynamic(dstStaticShape[dimIndex])) {
     return builder.getIndexAttr(dstStaticShape[dimIndex]);
   }
   AffineMap map = reassociationMap[dimIndex];
   unsigned startPos =
       map.getResults().front().cast<AffineDimExpr>().getPosition();
   unsigned endPos = map.getResults().back().cast<AffineDimExpr>().getPosition();
   AffineExpr expr;
   SmallVector<Value, 2> dynamicDims;

 }
 
 /// For an expanding reshape op, compute the value for a dimension of the output
 /// from the shape of the input.
 static OpFoldResult getExpandedOutputDimFromInputShape(
     OpBuilder &builder, Location loc, int64_t dimIndex, Value src,
     ArrayRef<int64_t> dstStaticShape, ArrayRef<AffineMap> reassociation,
     llvm::DenseMap<int64_t, int64_t> &expandedDimToCollapsedDim) {
-  if (!ShapedType::isDynamic(dstStaticShape[dimIndex])) {
+  if (!RankedShapedType::isDynamic(dstStaticShape[dimIndex])) {
     return builder.getIndexAttr(dstStaticShape[dimIndex]);
   }
   unsigned sourceDimPos = expandedDimToCollapsedDim[dimIndex];
   unsigned startPos = reassociation[sourceDimPos]
                           .getResults()
                           .front()
                           .cast<AffineDimExpr>()
                           .getPosition();
   unsigned endPos = reassociation[sourceDimPos]
                         .getResults()
                         .back()
                         .cast<AffineDimExpr>()
                         .getPosition();
   int64_t linearizedStaticDim = 1;
   for (auto d :
        llvm::enumerate(dstStaticShape.slice(startPos, endPos - startPos + 1))) {
     if (d.index() + startPos == static_cast<unsigned>(dimIndex))
       continue;
-    assert(!ShapedType::isDynamic(d.value()) &&
+    assert(!RankedShapedType::isDynamic(d.value()) &&
            "single dimension cannot be expanded into multiple dynamic "
            "dimensions");
     linearizedStaticDim *= d.value();
   }
   Value sourceDim = builder.create<tensor::DimOp>(loc, src, sourceDimPos);
   return applyMapToValues(
       builder, loc,
       AffineMap::get(
return llvm::to_vector<4>(llvm::map_range(
       }));
 }
 
 static SmallVector<OpFoldResult, 4>
 getReshapeOutputShapeFromInputShape(OpBuilder &builder, Location loc, Value src,
                                     ArrayRef<int64_t> dstStaticShape,
                                     ArrayRef<AffineMap> reassocation) {
   return dstStaticShape.size() >
-                 static_cast<size_t>(src.getType().cast<ShapedType>().getRank())
+                 static_cast<size_t>(
+                     src.getType().cast<RankedShapedType>().getRank())
              ? getExpandedOutputShapeFromInputShape(
                    builder, loc, src, dstStaticShape, reassocation)
              : getCollapsedOutputShapeFromInputShape(
                    builder, loc, src, dstStaticShape, reassocation);
 }
 
 template <typename OpTy>
 struct ReifyExpandOrCollapseShapeOp

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

for (int64_t i = 0; i < tensorType.getRank(); ++i) {
     }
   }
   return result;
 }
 
 FailureOr<Value> tensor::getOrCreateDestination(OpBuilder &b, Location loc,
                                                 OpResult opResult) {
   auto tensorType = opResult.getType().dyn_cast<TensorType>();
+  auto rankedTensorType = opResult.getType().dyn_cast<RankedTensorType>();
   assert(tensorType && "expected tensor type");
 
   // If the op has a destination, it implements DestinationStyleOpInterface and
   // we can query the destination operand from that interface.
   auto destOp = opResult.getDefiningOp<DestinationStyleOpInterface>();
   if (destOp)
     return destOp.getTiedOpOperand(opResult)->get();
 
   // Otherwise, create a new destination tensor with the same shape.
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPoint(opResult.getDefiningOp());
 
   // Compute sizes.
   SmallVector<OpFoldResult> mixedSizes;
-  if (!tensorType.hasStaticShape()) {
+  if (!rankedTensorType || !rankedTensorType.hasStaticShape()) {
     // Dynamic shape: Query ReifyRankedShapedTypeOpInterface.
     ReifiedRankedShapedTypeDims reifiedShapes;
     if (failed(reifyResultShapes(b, opResult.getDefiningOp(), reifiedShapes)))
       return failure();
     mixedSizes = reifiedShapes[opResult.getResultNumber()];
   } else {
     // Static shape: Take static sizes directly.
-    for (int64_t sz : tensorType.getShape())
+    for (int64_t sz : rankedTensorType.getShape())
       mixedSizes.push_back(b.getIndexAttr(sz));
   }
 
   // Create empty tensor.
   Value emptyTensor =
       b.create<tensor::EmptyOp>(loc, mixedSizes, tensorType.getElementType());
   return emptyTensor;
 }
if (sourceType.getElementType() != targetType.getElementType())
     return false;
 
   // Requires same rank.
   if (sourceType.getRank() != targetType.getRank())
     return false;
 
   // If cast is towards more static sizes along any dimension, don't fold.
   for (auto t : llvm::zip(sourceType.getShape(), targetType.getShape())) {
-    if (!ShapedType::isDynamic(std::get<0>(t)) &&
-        ShapedType::isDynamic(std::get<1>(t)))
+    if (!RankedShapedType::isDynamic(std::get<0>(t)) &&
+        RankedShapedType::isDynamic(std::get<1>(t)))
       return false;
   }
 
   return true;
 }
 
 /// Determines whether tensor::CastOp casts to a more dynamic version of the
 /// source tensor. This is useful to fold a tensor.cast into a consuming op and
bool CastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   return succeeded(verifyCompatibleShape(aT, bT));
 }
 
 /// Compute a TensorType that has the joined shape knowledge of the two
 /// given TensorTypes. The element types need to match.
 static TensorType joinShapes(TensorType one, TensorType two) {
   assert(one.getElementType() == two.getElementType());
 
-  if (!one.hasRank())
+  auto oneRanked = one.dyn_cast<RankedTensorType>();
+  if (!oneRanked)
     return two;
-  if (!two.hasRank())
+  auto twoRanked = two.dyn_cast<RankedTensorType>();
+  if (!twoRanked)
     return one;
 
-  int64_t rank = one.getRank();
-  if (rank != two.getRank())
+  int64_t rank = oneRanked.getRank();
+  if (rank != twoRanked.getRank())
     return {};
 
   SmallVector<int64_t, 4> join;
   join.reserve(rank);
   for (int64_t i = 0; i < rank; ++i) {
-    if (one.isDynamicDim(i)) {
-      join.push_back(two.getDimSize(i));
+    if (oneRanked.isDynamicDim(i)) {
+      join.push_back(twoRanked.getDimSize(i));
       continue;
     }
-    if (two.isDynamicDim(i)) {
-      join.push_back(one.getDimSize(i));
+    if (twoRanked.isDynamicDim(i)) {
+      join.push_back(oneRanked.getDimSize(i));
       continue;
     }
-    if (one.getDimSize(i) != two.getDimSize(i))
+    if (oneRanked.getDimSize(i) != twoRanked.getDimSize(i))
       return {};
-    join.push_back(one.getDimSize(i));
+    join.push_back(oneRanked.getDimSize(i));
   }
   return RankedTensorType::get(join, one.getElementType());
 }
 
 namespace {
 
 /// Replaces chains of two tensor.cast operations by a single tensor.cast
 /// operation if doing so does not remove runtime constraints.
LogicalResult matchAndRewrite(CastOp tensorCast,
     SmallVector<OpFoldResult, 4> sizes = extractOperand.getMixedSizes();
     auto dimMask = computeRankReductionMask(
         extractOperand.getStaticSizes(), extractOperand.getType().getShape());
     size_t dimIndex = 0;
     for (size_t i = 0, e = sizes.size(); i < e; i++) {
       if (dimMask && dimMask->count(i))
         continue;
       int64_t dim = rankedResultType.getShape()[dimIndex++];
-      if (ShapedType::isDynamic(dim))
+      if (RankedShapedType::isDynamic(dim))
         continue;
       sizes[i] = rewriter.getIndexAttr(dim);
     }
 
     rewriter.replaceOpWithNewOp<ExtractSliceOp>(
         tensorCast, rankedResultType, extractOperand.getSource(),
         extractOperand.getMixedOffsets(), sizes,
         extractOperand.getMixedStrides());
OpFoldResult DimOp::fold(FoldAdaptor adaptor) {
   Operation *definingOp = getSource().getDefiningOp();
 
   // Fold dim to the operand of tensor.generate.
   if (auto fromElements = dyn_cast_or_null<tensor::GenerateOp>(definingOp)) {
     auto resultType =
         fromElements.getResult().getType().cast<RankedTensorType>();
     // The case where the type encodes the size of the dimension is handled
     // above.
-    assert(ShapedType::isDynamic(resultType.getShape()[index.getInt()]));
+    assert(RankedShapedType::isDynamic(resultType.getShape()[index.getInt()]));
 
     // Find the operand of the fromElements that corresponds to this index.
     auto dynExtents = fromElements.getDynamicExtents().begin();
     for (auto dim : resultType.getShape().take_front(index.getInt()))
-      if (ShapedType::isDynamic(dim))
+      if (RankedShapedType::isDynamic(dim))
         dynExtents++;
 
     return Value{*dynExtents};
   }
 
   // The size at the given index is now known to be a dynamic size.
   unsigned unsignedIndex = index.getValue().getZExtValue();
 

 //===----------------------------------------------------------------------===//
 // EmptyOp
 //===----------------------------------------------------------------------===//
 
 void EmptyOp::build(OpBuilder &builder, OperationState &result,
                     ArrayRef<int64_t> staticShape, Type elementType,
                     Attribute encoding) {
   assert(all_of(staticShape,
-                [](int64_t sz) { return !ShapedType::isDynamic(sz); }) &&
+                [](int64_t sz) { return !RankedShapedType::isDynamic(sz); }) &&
          "expected only static sizes");
   build(builder, result, staticShape, elementType, ValueRange{}, encoding);
 }
 
 void EmptyOp::build(OpBuilder &builder, OperationState &result,
                     ArrayRef<int64_t> staticShape, Type elementType,
                     ValueRange dynamicSizes, Attribute encoding) {
   auto tensorType = RankedTensorType::get(staticShape, elementType, encoding);
LogicalResult matchAndRewrite(CastOp castOp,
     assert(resultShape.size() == currMixedSizes.size() &&
            "mismatch in result shape and sizes of empty op");
     for (auto it : llvm::zip(resultShape, currMixedSizes)) {
       int64_t newDim = std::get<0>(it);
       OpFoldResult currDim = std::get<1>(it);
       // Case 1: The empty tensor dim is static. Check that the tensor cast
       // result dim matches.
       if (auto attr = currDim.dyn_cast<Attribute>()) {
-        if (ShapedType::isDynamic(newDim) ||
+        if (RankedShapedType::isDynamic(newDim) ||
             newDim != attr.cast<IntegerAttr>().getInt()) {
           // Something is off, the cast result shape cannot be more dynamic
           // than the empty tensor result shape (enforced by
           // `canFoldIntoProducer`). Abort for now.
           return rewriter.notifyMatchFailure(
               producer, "mismatch in static value of shape of empty tensor "
                         "result and cast result");
         }
         newMixedSizes.push_back(attr);
         continue;
       }
 
       // Case 2 : The tensor cast shape is static, but empty tensor result
       // shape is dynamic.
-      if (!ShapedType::isDynamic(newDim)) {
+      if (!RankedShapedType::isDynamic(newDim)) {
         newMixedSizes.push_back(rewriter.getIndexAttr(newDim));
         continue;
       }
 
       // Case 3 : The tensor cast shape is dynamic and empty tensor result
       // shape is dynamic. Use the dynamic value from the empty tensor op.
       newMixedSizes.push_back(currDim);
     }
LogicalResult matchAndRewrite(GenerateOp tensorFromElements,
     if (resultType.hasStaticShape())
       return failure();
 
     SmallVector<Value, 4> newOperands;
     SmallVector<int64_t, 4> newShape;
     auto operandsIt = tensorFromElements.getDynamicExtents().begin();
 
     for (int64_t dim : resultType.getShape()) {
-      if (!ShapedType::isDynamic(dim)) {
+      if (!RankedShapedType::isDynamic(dim)) {
         newShape.push_back(dim);
         continue;
       }
       APInt index;
       if (!matchPattern(*operandsIt, m_ConstantInt(&index))) {
-        newShape.push_back(ShapedType::kDynamic);
+        newShape.push_back(RankedShapedType::kDynamic);
         newOperands.push_back(*operandsIt++);
         continue;
       }
       newShape.push_back(index.getSExtValue());
       operandsIt++;
     }
 
     if (newOperands.size() == tensorFromElements.getDynamicExtents().size())

 
 void RankOp::getAsmResultNames(function_ref<void(Value, StringRef)> setNameFn) {
   setNameFn(getResult(), "rank");
 }
 
 OpFoldResult RankOp::fold(FoldAdaptor adaptor) {
   // Constant fold rank when the rank of the operand is known.
   auto type = getOperand().getType();
-  auto shapedType = type.dyn_cast<ShapedType>();
-  if (shapedType && shapedType.hasRank())
+  auto shapedType = type.dyn_cast<RankedShapedType>();
+  if (shapedType)
     return IntegerAttr::get(IndexType::get(getContext()), shapedType.getRank());
   return IntegerAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
 
 void ReshapeOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   setNameFn(getResult(), "reshape");
 }
 
-static int64_t getNumElements(ShapedType type) {
+static int64_t getNumElements(RankedShapedType type) {
   int64_t numElements = 1;
   for (auto dim : type.getShape())
     numElements *= dim;
   return numElements;
 }
 
 LogicalResult ReshapeOp::verify() {
   TensorType operandType = getSource().getType().cast<TensorType>();
LogicalResult ReshapeOp::verify() {
 
   if (resultRankedType) {
     if (operandRankedType && resultRankedType.hasStaticShape() &&
         operandRankedType.hasStaticShape()) {
       if (getNumElements(operandRankedType) != getNumElements(resultRankedType))
         return emitOpError("source and destination tensor should have the "
                            "same number of elements");
     }
-    if (ShapedType::isDynamic(shapeSize))
+    if (RankedShapedType::isDynamic(shapeSize))
       return emitOpError("cannot use shape operand with dynamic length to "
                          "reshape to statically-ranked tensor type");
     if (shapeSize != resultRankedType.getRank())
       return emitOpError(
           "length of shape operand differs from the result's tensor rank");
   }
   return success();
 }
CollapseShapeOp::inferCollapsedType(RankedTensorType type,
   // Use the fact that reassociation is valid to simplify the logic: only use
   // each map's rank.
   assert(isReassociationValid(reassociation) && "invalid reassociation");
   unsigned currentDim = 0;
   for (AffineMap m : reassociation) {
     unsigned dim = m.getNumResults();
     auto band = shape.slice(currentDim, dim);
     int64_t size = 1;
-    if (llvm::is_contained(band, ShapedType::kDynamic))
-      size = ShapedType::kDynamic;
+    if (llvm::is_contained(band, RankedShapedType::kDynamic))
+      size = RankedShapedType::kDynamic;
     else
       for (unsigned d = 0; d < dim; ++d)
         size *= shape[currentDim + d];
     newShape.push_back(size);
     currentDim += dim;
   }
 
   return RankedTensorType::get(newShape, type.getElementType());
struct FoldReshapeWithFromElements : OpRewritePattern<TensorReshapeOp> {
   using OpRewritePattern<TensorReshapeOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(TensorReshapeOp reshapeOp,
                                 PatternRewriter &rewriter) const override {
     auto fromElements =
         reshapeOp.getSrc().template getDefiningOp<FromElementsOp>();
     if (!fromElements)
       return failure();
 
-    auto shapedTy = reshapeOp.getType().template cast<ShapedType>();
+    auto shapedTy = reshapeOp.getType().template dyn_cast<RankedShapedType>();
 
-    if (!shapedTy.hasStaticShape())
+    if (!shapedTy || !shapedTy.hasStaticShape())
       return failure();
 
     rewriter.replaceOpWithNewOp<FromElementsOp>(reshapeOp, reshapeOp.getType(),
                                                 fromElements.getElements());
     return success();
   }
 };
 
LogicalResult matchAndRewrite(ExtractSliceOp op,
     if (!matchPattern(op.getSource(), m_Constant(&attr)))
       return failure();
 
     // A constant splat is handled by fold().
     if (attr.isSplat())
       return failure();
 
     // Dynamic result shape is not supported.
-    auto sourceType = op.getSource().getType().cast<ShapedType>();
-    auto resultType = op.getResult().getType().cast<ShapedType>();
+    auto sourceType = op.getSource().getType().cast<RankedShapedType>();
+    auto resultType = op.getResult().getType().cast<RankedShapedType>();
     if (!sourceType.hasStaticShape() || !resultType.hasStaticShape())
       return failure();
 
     // Customized control over the folding.
     if (!controlFn(op))
       return failure();
 
     int64_t count = sourceType.getNumElements();
     if (count == 0)
       return failure();
 
     // Check if there are any dynamic parts, which are not supported.
     auto offsets = op.getStaticOffsets();
-    if (llvm::is_contained(offsets, ShapedType::kDynamic))
+    if (llvm::is_contained(offsets, RankedShapedType::kDynamic))
       return failure();
     auto sizes = op.getStaticSizes();
-    if (llvm::is_contained(sizes, ShapedType::kDynamic))
+    if (llvm::is_contained(sizes, RankedShapedType::kDynamic))
       return failure();
     auto strides = op.getStaticStrides();
-    if (llvm::is_contained(strides, ShapedType::kDynamic))
+    if (llvm::is_contained(strides, RankedShapedType::kDynamic))
       return failure();
 
     // Compute the stride for each dimension.
     SmallVector<int64_t> counts;
     ArrayRef<int64_t> shape = sourceType.getShape();
     counts.reserve(shape.size());
     for (int64_t v : shape) {
       count = count / v;
results.add<
       OpWithOffsetSizesAndStridesConstantArgumentFolder<
           ExtractSliceOp, SliceReturnTypeCanonicalizer, SliceCanonicalizer>,
       ExtractSliceOpCastFolder>(context);
 }
 
 //
 static LogicalResult
 foldIdentityOffsetSizeAndStrideOpInterface(OffsetSizeAndStrideOpInterface op,
-                                           ShapedType shapedType) {
+                                           RankedShapedType shapedType) {
   OpBuilder b(op.getContext());
   for (OpFoldResult ofr : op.getMixedOffsets())
     if (getConstantIntValue(ofr) != static_cast<int64_t>(0))
       return failure();
   // Rank-reducing noops only need to inspect the leading dimensions:
   // llvm::zip is appropriate.
   auto shape = shapedType.getShape();
   for (auto it : llvm::zip(op.getMixedSizes(), shape))
if (insertOp && insertOp.getSource().getType() == extractOp.getType() &&
       insertOp.isSameAs(extractOp, isSame))
     return insertOp.getSource();
 
   return {};
 }
 
 OpFoldResult ExtractSliceOp::fold(FoldAdaptor adaptor) {
   if (auto splat = adaptor.getSource().dyn_cast_or_null<SplatElementsAttr>()) {
-    auto resultType = getResult().getType().cast<ShapedType>();
-    if (resultType.hasStaticShape())
+    auto resultType = getResult().getType().dyn_cast<RankedShapedType>();
+    if (resultType && resultType.hasStaticShape())
       return splat.resizeSplat(resultType);
   }
   if (getSourceType() == getType() &&
       succeeded(foldIdentityOffsetSizeAndStrideOpInterface(*this, getType())))
     return this->getSource();
   if (Value slice = foldExtractAfterInsertSlice(*this))
     return slice;
 
if (staticLow.size() != rank)
     return RankedTensorType();
   if (staticHigh.size() != rank)
     return RankedTensorType();
   if (!(resultShape.empty() || resultShape.size() == rank))
     return RankedTensorType();
 
   SmallVector<int64_t, 4> inferredShape;
   for (auto i : llvm::seq<unsigned>(0, rank)) {
-    if (sourceType.isDynamicDim(i) || staticLow[i] == ShapedType::kDynamic ||
-        staticHigh[i] == ShapedType::kDynamic) {
-      inferredShape.push_back(resultShape.empty() ? ShapedType::kDynamic
+    if (sourceType.isDynamicDim(i) ||
+        staticLow[i] == RankedShapedType::kDynamic ||
+        staticHigh[i] == RankedShapedType::kDynamic) {
+      inferredShape.push_back(resultShape.empty() ? RankedShapedType::kDynamic
                                                   : resultShape[i]);
     } else {
       int64_t size = sourceType.getDimSize(i) + staticLow[i] + staticHigh[i];
       assert((resultShape.empty() || size == resultShape[i] ||
-              resultShape[i] == ShapedType::kDynamic) &&
+              resultShape[i] == RankedShapedType::kDynamic) &&
              "mismatch between inferred shape and result shape");
       inferredShape.push_back(size);
     }
   }
 
   return RankedTensorType::get(inferredShape, sourceType.getElementType());
 }
 
void PadOp::build(OpBuilder &b, OperationState &result, Type resultType,
   result.addAttributes(attrs);
 }
 
 void PadOp::build(OpBuilder &b, OperationState &result, Type resultType,
                   Value source, ValueRange low, ValueRange high, bool nofold,
                   ArrayRef<NamedAttribute> attrs) {
   auto sourceType = source.getType().cast<RankedTensorType>();
   unsigned rank = sourceType.getRank();
-  SmallVector<int64_t, 4> staticVector(rank, ShapedType::kDynamic);
+  SmallVector<int64_t, 4> staticVector(rank, RankedShapedType::kDynamic);
   build(b, result, resultType, source, staticVector, staticVector, low, high,
         nofold, attrs);
 }
 
 void PadOp::build(OpBuilder &b, OperationState &result, Type resultType,
                   Value source, ArrayRef<OpFoldResult> low,
                   ArrayRef<OpFoldResult> high, bool nofold,
                   ArrayRef<NamedAttribute> attrs) {
LogicalResult matchAndRewrite(PadOp padOp,
     // tensor::ExtractSliceOp does not match the size of the padded dimension.
     // Otherwise, take the size of the inner tensor::ExtractSliceOp.
     SmallVector<OpFoldResult> newSizes = innerSliceOp.getMixedSizes();
     for (auto en : enumerate(newSizes)) {
       if (!outerDims.test(en.index()))
         continue;
       OpFoldResult sliceSize = innerSliceOp.getMixedSizes()[en.index()];
       int64_t sourceSize = innerSliceOp.getSourceType().getShape()[en.index()];
-      assert(!ShapedType::isDynamic(sourceSize) &&
+      assert(!RankedShapedType::isDynamic(sourceSize) &&
              "expected padded dimension to have a static size");
       if (getConstantIntValue(sliceSize) != sourceSize) {
         return rewriter.notifyMatchFailure(
             padOp, "cannot fold since the inner ExtractSliceOp size does not "
                    "match the size of the outer padding");
       }
       en.value() = outerSliceOp.getMixedSizes()[en.index()];
     }
LogicalResult matchAndRewrite(PadOp padTensorOp,
 
     auto outputDims = oldResultType.getShape();
 
     // Extract the static info from the high and low operands.
     SmallVector<int64_t> constOperandsLow;
     for (auto operand : padTensorOp.getLow()) {
       APSInt intOp;
       if (!matchPattern(operand, m_ConstantInt(&intOp))) {
-        constOperandsLow.push_back(ShapedType::kDynamic);
+        constOperandsLow.push_back(RankedShapedType::kDynamic);
         continue;
       }
       constOperandsLow.push_back(intOp.getExtValue());
     }
     SmallVector<int64_t> constOperandsHigh;
     for (auto operand : padTensorOp.getHigh()) {
       APSInt intOp;
       if (!matchPattern(operand, m_ConstantInt(&intOp))) {
-        constOperandsHigh.push_back(ShapedType::kDynamic);
+        constOperandsHigh.push_back(RankedShapedType::kDynamic);
         continue;
       }
       constOperandsHigh.push_back(intOp.getExtValue());
     }
 
     SmallVector<int64_t> constLow(padTensorOp.getStaticLow());
     SmallVector<int64_t> constHigh(padTensorOp.getStaticHigh());
 
     // Verify the op is well-formed.
     if (inputDims.size() != outputDims.size() ||
         inputDims.size() != constLow.size() ||
         inputDims.size() != constHigh.size())
       return failure();
 
     auto lowCount = 0;
     auto highCount = 0;
     for (size_t i = 0; i < inputRank; i++) {
-      if (constLow[i] == ShapedType::kDynamic)
+      if (constLow[i] == RankedShapedType::kDynamic)
         constLow[i] = constOperandsLow[lowCount++];
-      if (constHigh[i] == ShapedType::kDynamic)
+      if (constHigh[i] == RankedShapedType::kDynamic)
         constHigh[i] = constOperandsHigh[highCount++];
     }
 
     auto staticLow = ArrayRef<int64_t>(constLow);
     auto staticHigh = ArrayRef<int64_t>(constHigh);
 
     // Calculate the output sizes with the static information.
     SmallVector<int64_t> newOutDims;
     for (size_t i = 0; i < inputRank; i++) {
-      if (outputDims[i] == ShapedType::kDynamic) {
+      if (outputDims[i] == RankedShapedType::kDynamic) {
         newOutDims.push_back(
-            (staticLow[i] == ShapedType::kDynamic ||
-                     staticHigh[i] == ShapedType::kDynamic ||
-                     inputDims[i] == ShapedType::kDynamic
-                 ? ShapedType::kDynamic
+            (staticLow[i] == RankedShapedType::kDynamic ||
+                     staticHigh[i] == RankedShapedType::kDynamic ||
+                     inputDims[i] == RankedShapedType::kDynamic
+                 ? RankedShapedType::kDynamic
                  : inputDims[i] + staticLow[i] + staticHigh[i]));
       } else {
         newOutDims.push_back(outputDims[i]);
       }
     }
 
     if (SmallVector<int64_t>(outputDims) == newOutDims ||
-        llvm::all_of(newOutDims,
-                     [&](int64_t x) { return x == ShapedType::kDynamic; }))
+        llvm::all_of(newOutDims, [&](int64_t x) {
+          return x == RankedShapedType::kDynamic;
+        }))
       return failure();
 
     // Rewrite the op using the new static type.
     auto newResultType = RankedTensorType::get(
         newOutDims, padTensorOp.getType().getElementType());
     auto newOp = rewriter.create<PadOp>(
         padTensorOp->getLoc(), newResultType, input, staticLow, staticHigh,
         padTensorOp.getLow(), padTensorOp.getHigh(), padTensorOp.getNofold(),

 template <typename OpTy>
 static LogicalResult
 reifyResultShapesImpl(OpTy op, OpBuilder &builder,
                       ReifiedRankedShapedTypeDims &reifiedReturnShapes) {
   static_assert(llvm::is_one_of<OpTy, PackOp, UnPackOp>::value,
                 "applies to only pack or unpack operations");
   int64_t destRank = op.getDestRank();
   reifiedReturnShapes.resize(1, SmallVector<OpFoldResult>(destRank));
-  ShapedType resultType = op.getResult().getType().template cast<ShapedType>();
+  auto resultType = op.getResult().getType().template cast<RankedShapedType>();
   for (auto dim : llvm::seq<int64_t>(0, destRank)) {
     if (resultType.isDynamicDim(dim)) {
       reifiedReturnShapes[0][dim] =
           builder.createOrFold<tensor::DimOp>(op.getLoc(), op.getDest(), dim);
     } else {
       reifiedReturnShapes[0][dim] =
           builder.getIndexAttr(resultType.getDimSize(dim));
     }

 template <typename OpTy>
 static SmallVector<OpFoldResult> getMixedTilesImpl(OpTy op) {
   static_assert(llvm::is_one_of<OpTy, PackOp, UnPackOp>::value,
                 "applies to only pack or unpack operations");
   Builder builder(op);
   SmallVector<OpFoldResult> mixedInnerTiles;
   unsigned dynamicValIndex = 0;
   for (int64_t staticTile : op.getStaticInnerTiles()) {
-    if (!ShapedType::isDynamic(staticTile))
+    if (!RankedShapedType::isDynamic(staticTile))
       mixedInnerTiles.push_back(builder.getI64IntegerAttr(staticTile));
     else
       mixedInnerTiles.push_back(op.getInnerTiles()[dynamicValIndex++]);
   }
   return mixedInnerTiles;
 }
 
 template <typename OpTy>
static bool areAllInBound(ArrayRef<int64_t> sourceShape,
                           ArrayRef<int64_t> limitShape) {
   assert(
       sourceShape.size() == limitShape.size() &&
       "expected source shape rank, and limit of the shape to have same rank");
   return llvm::all_of(
       llvm::zip(sourceShape, limitShape), [](std::tuple<int64_t, int64_t> it) {
         int64_t sourceExtent = std::get<0>(it);
         int64_t limit = std::get<1>(it);
-        return ShapedType::isDynamic(sourceExtent) ||
-               ShapedType::isDynamic(limit) || sourceExtent <= limit;
+        return RankedShapedType::isDynamic(sourceExtent) ||
+               RankedShapedType::isDynamic(limit) || sourceExtent <= limit;
       });
 }
 
 template <typename OpTy>
 static LogicalResult commonVerifierPackAndUnPackOp(OpTy packOrUnPack) {
   static_assert(llvm::is_one_of<OpTy, PackOp, UnPackOp>::value,
                 "applies to only pack or unpack operations");
   Operation *op = packOrUnPack.getOperation();
if (mixedTiles.size() > unpackedRank) {
     return op->emitError("tiling factors must be less than or equal to the "
                          "input rank for pack or output rank for unpack");
   }
   if (mixedTiles.size() != innerDimsPos.size()) {
     return op->emitError(
         "tiling factors must equal the number of dimensions to tile");
   }
 
-  ShapedType packedType = (std::is_same<OpTy, PackOp>::value)
+  RankedShapedType packedType = (std::is_same<OpTy, PackOp>::value)
                                     ? packOrUnPack.getDestType()
                                     : packOrUnPack.getSourceType();
   size_t packedRank = packedType.getRank();
   // Require output rank to match input rank + number of blocking factors.
   if (unpackedRank + mixedTiles.size() != packedRank) {
     return op->emitError(
         "packed rank must equal unpacked rank + tiling factors");
   }
 
   // Verify result shape is greater than the minimum expected
if (!llvm::all_of(
                     mixedTiles),
           [](std::tuple<int64_t, OpFoldResult> it) {
             std::optional<int64_t> constTileSize =
                 getConstantIntValue(std::get<1>(it));
             int64_t shape = std::get<0>(it);
             if (!constTileSize) {
               // If specified tile size is dynamic, output shape should
               // be dynamic too.
-              return ShapedType::isDynamic(shape);
+              return RankedShapedType::isDynamic(shape);
             }
-            if (ShapedType::isDynamic(shape)) {
+            if (RankedShapedType::isDynamic(shape)) {
               // For the shape being dynamic when tile size is
               // specified, return true. In canonical form a constant
               // tile size should lead to constant shape of the tiled
               // dimension, but not needed for verification.
               return true;
             }
             return shape == constTileSize.value();
           })) {

 SmallVector<int64_t> PackOp::getStaticTiles() {
   return getStaticTilesImpl(*this);
 }
 
 bool PackOp::requirePaddingValue(ArrayRef<int64_t> inputShape,
                                  ArrayRef<int64_t> innerDimsPos,
                                  ArrayRef<OpFoldResult> innerTiles) {
   for (auto [pos, tileSize] : llvm::zip_equal(innerDimsPos, innerTiles)) {
-    if (ShapedType::isDynamic(inputShape[pos]))
+    if (RankedShapedType::isDynamic(inputShape[pos]))
       continue;
     std::optional<int64_t> constantTile = getConstantIntValue(tileSize);
     if (!constantTile)
       continue;
     if (inputShape[pos] % (*constantTile) != 0)
       return true;
   }
   return false;

 /// Converts OpFoldResults to int64_t shape entries, unconditionally mapping all
 /// Value's to kDynamic, even if they are arith.constant values.
 static SmallVector<int64_t>
 asShapeWithAnyValueAsDynamic(ArrayRef<OpFoldResult> ofrs) {
   SmallVector<int64_t> result;
   for (auto o : ofrs) {
     // Have to do this first, as getConstantIntValue special-cases constants.
     if (o.dyn_cast<Value>())
-      result.push_back(ShapedType::kDynamic);
+      result.push_back(RankedShapedType::kDynamic);
     else
-      result.push_back(getConstantIntValue(o).value_or(ShapedType::kDynamic));
+      result.push_back(
+          getConstantIntValue(o).value_or(RankedShapedType::kDynamic));
   }
   return result;
 }
 
 /// Helper for PackOp::{getResultShape,inferPackedType}. Returns the shape of
 /// the packed type. Having a shared helper helps implement these two methods in
 /// a way that ensures that they agree on which dimensions are dynamic.
 static SmallVector<int64_t> getPackOpResultTypeShape(
     ArrayRef<int64_t> sourceShape, ArrayRef<int64_t> innerTileSizes,
     ArrayRef<int64_t> innerDimsPos, ArrayRef<int64_t> outerDimsPerm) {
   SmallVector<int64_t> resultShape = llvm::to_vector(sourceShape);
   for (auto tiledDim : llvm::enumerate(innerDimsPos)) {
-    if (ShapedType::isDynamic(resultShape[tiledDim.value()]))
+    if (RankedShapedType::isDynamic(resultShape[tiledDim.value()]))
       continue;
-    if (ShapedType::isDynamic(innerTileSizes[tiledDim.index()])) {
-      resultShape[tiledDim.value()] = ShapedType::kDynamic;
+    if (RankedShapedType::isDynamic(innerTileSizes[tiledDim.index()])) {
+      resultShape[tiledDim.value()] = RankedShapedType::kDynamic;
       continue;
     }
     resultShape[tiledDim.value()] = ceilDiv(resultShape[tiledDim.value()],
                                             innerTileSizes[tiledDim.index()]);
   }
 
   // Swap tile loops if outer_dims_perm is available.
   if (!outerDimsPerm.empty())
SmallVector<int64_t> resultTypeShape =
                                asShapeWithAnyValueAsDynamic(innerTileSizes),
                                innerDimsPos, outerDimsPerm);
 
   // Fix-up `resultDims` to ensure that they are Value's if and only if the
   // result type shape says it's a dynamic dim. This is needed as callers may
   // use dispatchIndexOpFoldResults on the result, and rely on exact number of
   // dynamic dims returned by that.
   for (unsigned i = 0; i < resultDims.size(); ++i) {
-    if (!ShapedType::isDynamic(resultTypeShape[i]))
+    if (!RankedShapedType::isDynamic(resultTypeShape[i]))
       continue;
     resultDims[i] =
         getValueOrCreateConstantIndexOp(builder, loc, resultDims[i]);
   }
 
   return resultDims;
 }
 
Value PackOp::createDestinationTensor(OpBuilder &b, Location loc, Value source,
   bindDims(b.getContext(), dim0, dim1);
   auto ceilDiv = [&](OpFoldResult v1, OpFoldResult v2) -> OpFoldResult {
     return makeComposedFoldedAffineApply(b, loc, dim0.ceilDiv(dim1), {v1, v2});
   };
 
   SmallVector<OpFoldResult> mixedSizes;
   for (auto [index, value] :
        llvm::enumerate(source.getType().cast<RankedTensorType>().getShape())) {
-    if (ShapedType::isDynamic(value))
+    if (RankedShapedType::isDynamic(value))
       mixedSizes.push_back(b.create<DimOp>(loc, source, index).getResult());
     else
       mixedSizes.push_back(b.getIndexAttr(value));
   }
   for (auto it : llvm::zip(innerDimsPos, innerTileSizes)) {
     int64_t dimPos = std::get<0>(it);
     OpFoldResult tileSize = std::get<1>(it);
     mixedSizes[dimPos] = ceilDiv(mixedSizes[dimPos], tileSize);
return b.create<PackOp>(loc, getSource(), transposedDest,
                           getPaddingValue(), metadata.outerDimsPerm);
 }
 
 /// Returns true if the tiles and the tiled dims are constant.
 template <typename OpTy>
 bool areTilesAndTiledDimsAllConstant(OpTy op) {
   static_assert(llvm::is_one_of<OpTy, PackOp, UnPackOp>::value,
                 "applies to only pack or unpack operations");
-  ShapedType packedType = (std::is_same<OpTy, PackOp>::value)
+  RankedShapedType packedType = (std::is_same<OpTy, PackOp>::value)
                                     ? op.getDestType()
                                     : op.getSourceType();
   SmallVector<OpFoldResult> mixedTiles = op.getMixedTiles();
   for (auto [dimDest, tile] : llvm::zip(
            packedType.getShape().take_back(mixedTiles.size()), mixedTiles)) {
     std::optional<int64_t> constTileSize = getConstantIntValue(tile);
-    if (!constTileSize || ShapedType::isDynamic(dimDest))
+    if (!constTileSize || RankedShapedType::isDynamic(dimDest))
       return false;
   }
   return true;
 }
 
 Speculation::Speculatability PackOp::getSpeculatability() {
   if (auto paddingValue = getPaddingValue())
     return Speculation::Speculatable;

mlir/lib/Dialect/Tensor/Utils/Utils.cpp

 PadOp mlir::tensor::createPadHighOp(RankedTensorType type, Value source,
                                     Value pad, bool nofold, Location loc,
                                     OpBuilder &b) {
   auto zero = b.createOrFold<arith::ConstantIndexOp>(loc, 0);
   SmallVector<OpFoldResult> low(type.getRank(), zero);
   SmallVector<OpFoldResult> high(type.getRank(), zero);
   for (const auto &en : enumerate(type.getShape())) {
     // Pad only the static dimensions of the result tensor type.
-    if (ShapedType::isDynamic(en.value()))
+    if (RankedShapedType::isDynamic(en.value()))
       continue;
     // Compute the padding width.
     AffineExpr d0;
     bindDims(b.getContext(), d0);
     auto dimOp = b.createOrFold<tensor::DimOp>(loc, source, en.index());
     high[en.index()] =
         makeComposedAffineApply(b, loc, en.value() - d0, {dimOp}).getResult();
   }
   return b.create<PadOp>(loc, type, source, low, high, pad, nofold);
 }
 
 SmallVector<Value> mlir::tensor::createDynamicDimValues(OpBuilder &b,
                                                         Location loc,
                                                         Value rankedTensor) {
   auto tensorTy = rankedTensor.getType().cast<RankedTensorType>();
   SmallVector<Value> dynamicDims;
   for (const auto &en : llvm::enumerate(tensorTy.getShape())) {
-    if (en.value() == ShapedType::kDynamic)
+    if (en.value() == RankedShapedType::kDynamic)
       dynamicDims.push_back(
           b.create<tensor::DimOp>(loc, rankedTensor, en.index()));
   }
   return dynamicDims;
 }
 
 FailureOr<OpFoldResult> mlir::tensor::createDimValue(OpBuilder &b, Location loc,
                                                      Value rankedTensor,
                                                      int64_t dim) {
   auto tensorTy = rankedTensor.getType().dyn_cast<RankedTensorType>();
   if (!tensorTy)
     return failure();
   auto shape = tensorTy.getShape();
   if (dim >= static_cast<int64_t>(shape.size()))
     return failure();
-  if (ShapedType::isDynamic(shape[dim]))
+  if (RankedShapedType::isDynamic(shape[dim]))
     return OpFoldResult(b.createOrFold<tensor::DimOp>(loc, rankedTensor, dim));
   return OpFoldResult(b.getIndexAttr(shape[dim]));
 }
 
 SmallVector<OpFoldResult>
 mlir::tensor::createDimValues(OpBuilder &b, Location loc, Value rankedTensor) {
   auto tensorTy = rankedTensor.getType().cast<RankedTensorType>();
   SmallVector<OpFoldResult> dims;
   for (const auto &en : llvm::enumerate(tensorTy.getShape())) {
-    if (ShapedType::isDynamic(en.value())) {
+    if (RankedShapedType::isDynamic(en.value())) {
       dims.push_back(
           b.createOrFold<tensor::DimOp>(loc, rankedTensor, en.index()));
     } else {
       dims.push_back(b.getIndexAttr(en.value()));
     }
   }
   return dims;
 }

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

LogicalResult matchAndRewrite(tosa::TransposeOp op,
     Value result = op.getResult();
     for (Operation *subop : result.getUsers()) {
       if (dyn_cast_or_null<tosa::TransposeOp>(subop))
         return rewriter.notifyMatchFailure(
             op, "Dest is used by transpose, can compose transposes");
     }
 
     auto input = op.getInput1();
-    auto inputTy = input.getType().cast<ShapedType>();
-    if (!inputTy.hasRank())
+    auto inputTy = input.getType().dyn_cast<RankedShapedType>();
+    if (!inputTy)
       return rewriter.notifyMatchFailure(op, "Unranked input.");
 
     int64_t numDynDims = 0;
     for (int i = 0; i < inputTy.getRank(); ++i)
       if (inputTy.isDynamicDim(i))
         numDynDims++;
 
     if (numDynDims > 1)

 
 struct MaxPool2dIsNoOp : public OpRewritePattern<tosa::MaxPool2dOp> {
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::MaxPool2dOp op,
                                 PatternRewriter &rewriter) const override {
     Value input = op.getInput();
     Value output = op.getOutput();
-    ShapedType inputType = input.getType().cast<ShapedType>();
-    ShapedType outputType = output.getType().cast<ShapedType>();
+    auto inputType = input.getType().cast<RankedShapedType>();
+    auto outputType = output.getType().cast<RankedShapedType>();
 
     if (!inputType.hasStaticShape() || !outputType.hasStaticShape()) {
       return failure();
     }
 
     // If the output and input shapes are 1x1, then this is a no op.
     ArrayRef<int64_t> outputShape = outputType.getShape();
     if (outputShape[1] != 1 || outputShape[2] != 1) {
OpFoldResult CastOp::fold(FoldAdaptor adaptor) {
 
   return {};
 }
 
 OpFoldResult ConstOp::fold(FoldAdaptor adaptor) { return getValueAttr(); }
 
 #define REDUCE_FOLDER(OP)                                                      \
   OpFoldResult OP::fold(FoldAdaptor adaptor) {                                 \
-    ShapedType inputTy = getInput().getType().cast<ShapedType>();              \
-    if (!inputTy.hasRank())                                                    \
+    auto inputTy = getInput().getType().dyn_cast<RankedShapedType>();          \
+    if (!inputTy)                                                              \
       return {};                                                               \
     if (inputTy.getDimSize(getAxis()) == 1)                                    \
       return getInput();                                                       \
     return {};                                                                 \
   }
 
 REDUCE_FOLDER(ReduceAllOp)
 REDUCE_FOLDER(ReduceAnyOp)
OpFoldResult ResizeOp::fold(FoldAdaptor adaptor) {
   if (inputTy != resultTy)
     return {};
 
   return input;
 }
 
 OpFoldResult ReverseOp::fold(FoldAdaptor adaptor) {
   auto operand = getInput();
-  auto operandTy = operand.getType().cast<ShapedType>();
+  auto operandTy = operand.getType().dyn_cast<RankedShapedType>();
   auto axis = getAxis();
   auto operandAttr = adaptor.getInput().dyn_cast_or_null<SplatElementsAttr>();
   if (operandAttr)
     return operandAttr;
 
   // If the dim-length is 1, tosa.reverse is a no-op.
-  if (operandTy.hasRank() && operandTy.getDimSize(axis) == 1)
+  if (operandTy && operandTy.getDimSize(axis) == 1)
     return operand;
 
   return {};
 }
 
 OpFoldResult SliceOp::fold(FoldAdaptor adaptor) {
   auto inputTy = getInput().getType().dyn_cast<RankedTensorType>();
   auto outputTy = getType().dyn_cast<RankedTensorType>();

 OpFoldResult TileOp::fold(FoldAdaptor adaptor) {
   bool allOnes = llvm::all_of(getMultiples(), [](int64_t v) { return v == 1; });
   if (allOnes && getInput1().getType() == getType())
     return getInput1();
   return {};
 }
 
 OpFoldResult TransposeOp::fold(FoldAdaptor adaptor) {
-  auto inputTy = getInput1().getType().cast<ShapedType>();
-  auto resultTy = getType().cast<ShapedType>();
+  auto inputTy = getInput1().getType().cast<RankedShapedType>();
+  auto resultTy = getType().cast<RankedShapedType>();
 
   // Transposing splat values just means reshaping.
   if (auto input = adaptor.getInput1().dyn_cast_or_null<DenseElementsAttr>()) {
     if (input.isSplat() && resultTy.hasStaticShape() &&
         inputTy.getElementType() == resultTy.getElementType())
       return input.reshape(resultTy);
   }
 

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

LogicalResult tosa::RFFT2dOp::inferReturnTypeComponents(
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
 
   if (!inputShape.hasRank())
     return failure();
 
   llvm::SmallVector<int64_t> outputShape;
-  outputShape.resize(3, ShapedType::kDynamic);
+  outputShape.resize(3, RankedShapedType::kDynamic);
   outputShape[0] = inputShape.getDimSize(0);
   outputShape[1] = inputShape.getDimSize(1);
   int64_t inWidth = inputShape.getDimSize(2);
 
   // Note that we can support this calculation symbolically
   // in the future e.g. [x, y, z] -> [x, y, z / 2 - 1]
-  if (inWidth != ShapedType::kDynamic)
+  if (inWidth != RankedShapedType::kDynamic)
     outputShape[2] = inWidth / 2 + 1;
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
 
   return success();
 }
 
LogicalResult tosa::ConcatOp::inferReturnTypeComponents(
   bool hasRankedInput = false;
   for (auto operand : operands) {
     ShapeAdaptor operandShape = operands.getShape(operand);
     if (!operandShape.hasRank())
       continue;
 
     // Copy the Operand's rank.
     if (!hasRankedInput)
-      outputShape.resize(operandShape.getRank(), ShapedType::kDynamic);
+      outputShape.resize(operandShape.getRank(), RankedShapedType::kDynamic);
 
     // Copy shapes until the dim is non-dynamic.
     for (int i = 0, s = operandShape.getRank(); i < s; i++) {
       if (i == axis || operandShape.isDynamicDim(i))
         continue;
-      if (outputShape[i] == ShapedType::kDynamic)
+      if (outputShape[i] == RankedShapedType::kDynamic)
         outputShape[i] = operandShape.getDimSize(i);
       if (outputShape[i] != operandShape.getDimSize(i))
         return emitOptionalError(location,
                                  "Cannot concat tensors with different sizes"
                                  " on the non-axis dimension ",
                                  i);
     }
 
     hasRankedInput = true;
   }
   Type inputType = operands.getType()[0].cast<TensorType>().getElementType();
   if (!hasRankedInput) {
     inferredReturnShapes.push_back(ShapedTypeComponents(inputType));
     return success();
   }
 
   // Determine the dimension size along the concatenation axis.
   int64_t concatDimSize = 0;
   for (auto operand : operands) {
     ShapeAdaptor operandShape = operands.getShape(operand);
 
     // We need to know the length of the concatenation axis of all inputs to
     // determine the dimension size of the output shape.
     if (!operandShape.hasRank() || operandShape.isDynamicDim(axis)) {
-      concatDimSize = ShapedType::kDynamic;
+      concatDimSize = RankedShapedType::kDynamic;
       break;
     }
 
     concatDimSize += operandShape.getDimSize(axis);
   }
 
   outputShape[axis] = concatDimSize;
 
LogicalResult tosa::FullyConnectedOp::inferReturnTypeComponents(
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   ShapeAdaptor weightShape = operands.getShape(1);
   ShapeAdaptor biasShape = operands.getShape(2);
 
   // All shapes are dynamic.
   SmallVector<int64_t> outShape;
-  outShape.resize(2, ShapedType::kDynamic);
+  outShape.resize(2, RankedShapedType::kDynamic);
 
   if (inputShape.hasRank()) {
     outShape[0] = inputShape.getDimSize(0);
   }
 
   if (weightShape.hasRank()) {
     outShape[1] = weightShape.getDimSize(0);
   }
 
   if (biasShape.hasRank()) {
-    outShape[1] = outShape[1] == ShapedType::kDynamic ? biasShape.getDimSize(0)
-                                                      : outShape[1];
+    outShape[1] = outShape[1] == RankedShapedType::kDynamic
+                      ? biasShape.getDimSize(0)
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outShape));
   return success();
 }
 
 LogicalResult FullyConnectedOp::verify() { return verifyConvOp(*this); }
 
 LogicalResult tosa::MatMulOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor lhsShape = operands.getShape(0);
   ShapeAdaptor rhsShape = operands.getShape(1);
 
   // All shapes are dynamic.
   SmallVector<int64_t> outShape;
-  outShape.resize(3, ShapedType::kDynamic);
+  outShape.resize(3, RankedShapedType::kDynamic);
 
   if (lhsShape.hasRank()) {
     outShape[0] = lhsShape.getDimSize(0);
     outShape[1] = lhsShape.getDimSize(1);
   }
 
   if (rhsShape.hasRank()) {
-    outShape[0] = outShape[0] == ShapedType::kDynamic ? rhsShape.getDimSize(0)
-                                                      : outShape[0];
+    outShape[0] = outShape[0] == RankedShapedType::kDynamic
+                      ? rhsShape.getDimSize(0)
     outShape[2] = rhsShape.getDimSize(2);
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outShape));
   return success();
 }
 
 LogicalResult tosa::PadOp::inferReturnTypeComponents(
LogicalResult tosa::PadOp::inferReturnTypeComponents(
   // If the input rank is unknown we can info the output rank using the padding
   // shape's first dim.
   if (!inputShape.hasRank()) {
     if (paddingShape.isDynamicDim(0)) {
       inferredReturnShapes.push_back(ShapedTypeComponents());
       return success();
     }
 
-    outputShape.resize(paddingShape.getDimSize(0), ShapedType::kDynamic);
+    outputShape.resize(paddingShape.getDimSize(0), RankedShapedType::kDynamic);
     inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
     return success();
   }
 
   DenseIntElementsAttr paddings;
   // If the paddings value is not a constant, all dimensions must be dynamic.
   if (!matchPattern(operands[1], m_Constant(&paddings))) {
-    outputShape.resize(inputShape.getRank(), ShapedType::kDynamic);
+    outputShape.resize(inputShape.getRank(), RankedShapedType::kDynamic);
     inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
     return success();
   }
 
   SmallVector<int64_t> paddingValues;
   for (auto val : paddings) {
     paddingValues.push_back(val.getSExtValue());
   }
 
   outputShape.reserve(inputShape.getRank());
   for (int i = 0, s = inputShape.getRank(); i < s; i++) {
     if (inputShape.isDynamicDim(i)) {
-      outputShape.push_back(ShapedType::kDynamic);
+      outputShape.push_back(RankedShapedType::kDynamic);
       continue;
     }
 
     outputShape.push_back(inputShape.getDimSize(i) + paddingValues[i * 2] +
                           paddingValues[i * 2 + 1]);
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 static SmallVector<int64_t> convertToMlirShape(ArrayRef<int64_t> shape) {
   return to_vector(llvm::map_range(shape, [](int64_t dim) {
-    return dim == -1 ? ShapedType::kDynamic : dim;
+    return dim == -1 ? RankedShapedType::kDynamic : dim;
   }));
 }
 
 LogicalResult tosa::SliceOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   inferredReturnShapes.push_back(ShapedTypeComponents(
LogicalResult tosa::TileOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   TileOpAdaptor adaptor(operands, attributes);
   ArrayRef<int64_t> multiples = adaptor.getMultiples();
   ShapeAdaptor inputShape = operands.getShape(0);
   SmallVector<int64_t> outputShape;
   if (!inputShape.hasRank()) {
-    outputShape.resize(multiples.size(), ShapedType::kDynamic);
+    outputShape.resize(multiples.size(), RankedShapedType::kDynamic);
     inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
     return success();
   }
 
   // Any non dynamic dimension can be multiplied to a known size.
   outputShape.reserve(multiples.size());
   for (int i = 0, s = inputShape.getRank(); i < s; i++) {
     int64_t dim = inputShape.getDimSize(i);
-    if (dim != ShapedType::kDynamic)
+    if (dim != RankedShapedType::kDynamic)
       dim *= multiples[i];
     outputShape.push_back(dim);
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
LogicalResult tosa::ReshapeOp::inferReturnTypeComponents(
   }
 
   // Determine the number of elements covered by the slice of all static
   // dimensions. This allows us to infer the length of the remaining dynamic
   // dimension.
   int64_t numElements = inputShape.getNumElements();
   int64_t staticMul = 1;
   for (auto val : newShapeValue) {
-    if (!ShapedType::isDynamic(val)) {
+    if (!RankedShapedType::isDynamic(val)) {
       staticMul *= val;
     }
   }
 
   // Determine the length of the dynamic dimension.
   for (auto &val : newShapeValue) {
-    if (ShapedType::isDynamic(val))
+    if (RankedShapedType::isDynamic(val))
       val = numElements / staticMul;
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(newShapeValue));
   return success();
 }
 
 mlir::LogicalResult tosa::ReshapeOp::verify() {
-  ShapedType inputType = getInput1().getType().cast<ShapedType>();
-  ShapedType outputType = getType().cast<ShapedType>();
+  auto inputType = getInput1().getType().dyn_cast<RankedShapedType>();
+  auto outputType = getType().dyn_cast<RankedShapedType>();
 
-  if (inputType.hasStaticShape() && outputType.hasStaticShape()) {
+  if (inputType && inputType.hasStaticShape() && outputType &&
+      outputType.hasStaticShape()) {
     int64_t inputElementsNum = inputType.getNumElements();
     int64_t outputElementsNum = outputType.getNumElements();
     if (inputElementsNum != outputElementsNum) {
       return emitOpError() << "Cannot reshape " << inputElementsNum
                            << " elements into " << outputElementsNum;
     }
   }
   return mlir::success();
LogicalResult tosa::TransposeOp::inferReturnTypeComponents(
   if (permsShape.getDimSize(0) != inputShape.getRank()) {
     return failure();
   }
 
   // Without the input dims we cannot determine the output dim sizes but we
   // can determine the output rank.
   SmallVector<int64_t> outputShape;
   if (!inputShape.hasRank()) {
-    outputShape.resize(permsShape.getDimSize(0), ShapedType::kDynamic);
+    outputShape.resize(permsShape.getDimSize(0), RankedShapedType::kDynamic);
     inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
     return success();
   }
 
   // Rank-0 means no permutations matter.
   if (inputShape.getRank() == 0) {
     inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
     return success();
LogicalResult tosa::TransposeOp::inferReturnTypeComponents(
   // If all of the input dimensions are the same we don't care about the
   // permutation.
   if (allTheSame) {
     outputShape.resize(inputShape.getRank(), inputShape.getDimSize(0));
     inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
     return success();
   }
 
-  outputShape.resize(inputShape.getRank(), ShapedType::kDynamic);
+  outputShape.resize(inputShape.getRank(), RankedShapedType::kDynamic);
   // If the permuations are a constant we can directly determine the output
   // shape.
   if (ShapeAdaptor permShape = operands.getValueAsShape(1)) {
     outputShape.reserve(inputShape.getRank());
     for (int i = 0, s = inputShape.getRank(); i < s; i++) {
       outputShape[i] = inputShape.getDimSize(permShape.getDimSize(i));
     }
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::GatherOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape;
-  outputShape.resize(3, ShapedType::kDynamic);
+  outputShape.resize(3, RankedShapedType::kDynamic);
 
   ShapeAdaptor valuesShape = operands.getShape(0);
   if (valuesShape.hasRank()) {
     outputShape[0] = valuesShape.getDimSize(0);
     outputShape[2] = valuesShape.getDimSize(2);
   }
 
   ShapeAdaptor indicesShape = operands.getShape(1);
   if (indicesShape.hasRank()) {
-    if (outputShape[0] == ShapedType::kDynamic)
+    if (outputShape[0] == RankedShapedType::kDynamic)
       outputShape[0] = indicesShape.getDimSize(0);
-    if (outputShape[1] == ShapedType::kDynamic)
+    if (outputShape[1] == RankedShapedType::kDynamic)
       outputShape[1] = indicesShape.getDimSize(1);
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::ResizeOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ResizeOpAdaptor adaptor(operands, attributes);
   llvm::SmallVector<int64_t, 4> outputShape;
-  outputShape.resize(4, ShapedType::kDynamic);
+  outputShape.resize(4, RankedShapedType::kDynamic);
 
   ShapeAdaptor inputShape = operands.getShape(adaptor.getInput());
   if (!inputShape.hasRank())
     return failure();
 
   outputShape[0] = inputShape.getDimSize(0);
   outputShape[3] = inputShape.getDimSize(3);
   int64_t inputHeight = inputShape.getDimSize(1);
   int64_t inputWidth = inputShape.getDimSize(2);
 
-  if ((inputHeight == ShapedType::kDynamic) ||
-      (inputWidth == ShapedType::kDynamic))
+  if ((inputHeight == RankedShapedType::kDynamic) ||
+      (inputWidth == RankedShapedType::kDynamic))
     return failure();
 
   llvm::ArrayRef<int64_t> scaleInt = adaptor.getScale();
   llvm::ArrayRef<int64_t> offsetInt = adaptor.getOffset();
   llvm::ArrayRef<int64_t> borderInt = adaptor.getBorder();
 
   // Compute the output shape based on attributes: scale, offset, and border.
   outputShape[1] =
LogicalResult tosa::ResizeOp::inferReturnTypeComponents(
   return success();
 }
 
 LogicalResult tosa::ScatterOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape;
-  outputShape.resize(3, ShapedType::kDynamic);
+  outputShape.resize(3, RankedShapedType::kDynamic);
 
   ShapeAdaptor valuesInShape = operands.getShape(0);
   if (valuesInShape.hasRank()) {
     outputShape[0] = valuesInShape.getDimSize(0);
     outputShape[1] = valuesInShape.getDimSize(1);
     outputShape[2] = valuesInShape.getDimSize(2);
   }
 
   ShapeAdaptor indicesShape = operands.getShape(1);
   if (indicesShape.hasRank()) {
-    if (outputShape[0] == ShapedType::kDynamic)
+    if (outputShape[0] == RankedShapedType::kDynamic)
       outputShape[0] = indicesShape.getDimSize(0);
   }
 
   ShapeAdaptor inputShape = operands.getShape(2);
   if (inputShape.hasRank()) {
-    if (outputShape[0] == ShapedType::kDynamic)
+    if (outputShape[0] == RankedShapedType::kDynamic)
       outputShape[0] = inputShape.getDimSize(0);
-    if (outputShape[2] == ShapedType::kDynamic)
+    if (outputShape[2] == RankedShapedType::kDynamic)
       outputShape[2] = inputShape.getDimSize(2);
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 static LogicalResult ReduceInferReturnTypes(

 NARY_SHAPE_INFER(tosa::SigmoidOp)
 #undef PRED_SHAPE_INFER
 
 static LogicalResult poolingInferReturnTypes(
     const ValueShapeRange &operands, DictionaryAttr attributes,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   llvm::SmallVector<int64_t> outputShape;
-  outputShape.resize(4, ShapedType::kDynamic);
+  outputShape.resize(4, RankedShapedType::kDynamic);
 
   // We only know the rank if the input type is unranked.
   if (!inputShape) {
     inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
     return success();
   }
 
   // Batch and number of channels are identical for pooling layer.
   outputShape[0] = inputShape.getDimSize(0);
   outputShape[3] = inputShape.getDimSize(3);
 
   int64_t height = inputShape.getDimSize(1);
   int64_t width = inputShape.getDimSize(2);
 
   ArrayRef<int64_t> kernel = attributes.get("kernel").cast<DenseI64ArrayAttr>();
   ArrayRef<int64_t> stride = attributes.get("stride").cast<DenseI64ArrayAttr>();
   ArrayRef<int64_t> pad = attributes.get("pad").cast<DenseI64ArrayAttr>();
 
-  if (!ShapedType::isDynamic(height)) {
+  if (!RankedShapedType::isDynamic(height)) {
     int64_t padded = height + pad[0] + pad[1] - kernel[0];
     outputShape[1] = padded / stride[0] + 1;
   }
 
-  if (!ShapedType::isDynamic(width)) {
+  if (!RankedShapedType::isDynamic(width)) {
     int64_t padded = width + pad[2] + pad[3] - kernel[1];
     outputShape[2] = padded / stride[1] + 1;
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult Conv2DOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
-  llvm::SmallVector<int64_t> outputShape(4, ShapedType::kDynamic);
+  llvm::SmallVector<int64_t> outputShape(4, RankedShapedType::kDynamic);
   Conv2DOp::Adaptor adaptor(operands.getValues(), attributes);
 
-  int64_t inputWidth = ShapedType::kDynamic;
-  int64_t inputHeight = ShapedType::kDynamic;
-  int64_t weightWidth = ShapedType::kDynamic;
-  int64_t weightHeight = ShapedType::kDynamic;
+  int64_t inputWidth = RankedShapedType::kDynamic;
+  int64_t inputHeight = RankedShapedType::kDynamic;
+  int64_t weightWidth = RankedShapedType::kDynamic;
+  int64_t weightHeight = RankedShapedType::kDynamic;
 
   // Input shape describes input width/height and batch.
 
   ShapeAdaptor inputShape = operands.getShape(adaptor.getInput());
   if (inputShape.hasRank()) {
     outputShape[0] = inputShape.getDimSize(0);
     inputHeight = inputShape.getDimSize(1);
     inputWidth = inputShape.getDimSize(2);
   }
 
   // Weight shapes describes the filter width/height and the output channels.
   ShapeAdaptor weightShape = operands.getShape(adaptor.getWeight());
   if (weightShape.hasRank()) {
     outputShape[3] = weightShape.getDimSize(0);
     weightHeight = weightShape.getDimSize(1);
     weightWidth = weightShape.getDimSize(2);
   }
 
   // Bias shape can describe the output channels.
   ShapeAdaptor biasShape = operands.getShape(adaptor.getBias());
   if (biasShape.hasRank()) {
-    outputShape[3] = ShapedType::isDynamic(outputShape[3])
+    outputShape[3] = RankedShapedType::isDynamic(outputShape[3])
                          ? biasShape.getDimSize(0)
                          : outputShape[3];
   }
 
   llvm::ArrayRef<int64_t> dilation = adaptor.getDilation();
   llvm::ArrayRef<int64_t> stride = adaptor.getStride();
   llvm::ArrayRef<int64_t> padding = adaptor.getPad();
 
-  if (!ShapedType::isDynamic(inputHeight) &&
-      !ShapedType::isDynamic(weightHeight)) {
+  if (!RankedShapedType::isDynamic(inputHeight) &&
+      !RankedShapedType::isDynamic(weightHeight)) {
     int64_t inputSize = inputHeight + padding[0] + padding[1];
     int64_t filterSize = (weightHeight - 1) * dilation[0] + 1;
     int64_t unstridedResult = inputSize - filterSize + 1;
     outputShape[1] = (unstridedResult - 1) / stride[0] + 1;
   }
 
-  if (!ShapedType::isDynamic(inputWidth) &&
-      !ShapedType::isDynamic(weightWidth)) {
+  if (!RankedShapedType::isDynamic(inputWidth) &&
+      !RankedShapedType::isDynamic(weightWidth)) {
     int64_t inputSize = inputWidth + padding[2] + padding[3];
     int64_t filterSize = (weightWidth - 1) * dilation[1] + 1;
     int64_t unstridedResult = inputSize - filterSize + 1;
     outputShape[2] = (unstridedResult - 1) / stride[1] + 1;
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult Conv2DOp::verify() { return verifyConvOp(*this); }
 
 LogicalResult Conv3DOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
-  llvm::SmallVector<int64_t> outputShape(5, ShapedType::kDynamic);
+  llvm::SmallVector<int64_t> outputShape(5, RankedShapedType::kDynamic);
   Conv3DOp::Adaptor adaptor(operands.getValues(), attributes);
 
-  int64_t inputWidth = ShapedType::kDynamic;
-  int64_t inputHeight = ShapedType::kDynamic;
-  int64_t inputDepth = ShapedType::kDynamic;
-
-  int64_t weightWidth = ShapedType::kDynamic;
-  int64_t weightHeight = ShapedType::kDynamic;
-  int64_t weightDepth = ShapedType::kDynamic;
+  int64_t inputWidth = RankedShapedType::kDynamic;
+  int64_t inputHeight = RankedShapedType::kDynamic;
+  int64_t inputDepth = RankedShapedType::kDynamic;
+
+  int64_t weightWidth = RankedShapedType::kDynamic;
+  int64_t weightHeight = RankedShapedType::kDynamic;
+  int64_t weightDepth = RankedShapedType::kDynamic;
 
   // Input shape describes input width/height and batch.
   ShapeAdaptor inputShape = operands.getShape(adaptor.getInput());
   if (inputShape.hasRank()) {
     outputShape[0] = inputShape.getDimSize(0);
     inputDepth = inputShape.getDimSize(1);
     inputHeight = inputShape.getDimSize(2);
     inputWidth = inputShape.getDimSize(3);
   }
 
   // Weight shapes describes the filter width/height and the output channels.
   ShapeAdaptor weightShape = operands.getShape(adaptor.getWeight());
   if (weightShape.hasRank()) {
     outputShape[4] = weightShape.getDimSize(0);
     weightDepth = weightShape.getDimSize(1);
     weightHeight = weightShape.getDimSize(2);
     weightWidth = weightShape.getDimSize(3);
   }
 
   // Bias shape can describe the output channels.
   ShapeAdaptor biasShape = operands.getShape(adaptor.getBias());
-  if (biasShape.hasRank() && ShapedType::isDynamic(outputShape[4])) {
+  if (biasShape.hasRank() && RankedShapedType::isDynamic(outputShape[4])) {
     outputShape[4] = biasShape.getDimSize(0);
   }
 
   llvm::ArrayRef<int64_t> dilation = adaptor.getDilation();
   llvm::ArrayRef<int64_t> stride = adaptor.getStride();
   llvm::ArrayRef<int64_t> pad = adaptor.getPad();
 
-  if (!ShapedType::isDynamic(inputDepth) &&
-      !ShapedType::isDynamic(weightDepth)) {
+  if (!RankedShapedType::isDynamic(inputDepth) &&
+      !RankedShapedType::isDynamic(weightDepth)) {
     int32_t inputSize = inputDepth + pad[0] + pad[1];
     int32_t filterSize = (weightDepth - 1) * dilation[0] + 1;
     int32_t unstridedResult = inputSize - filterSize + 1;
     outputShape[1] = (unstridedResult - 1) / stride[0] + 1;
   }
 
-  if (!ShapedType::isDynamic(inputHeight) &&
-      !ShapedType::isDynamic(weightHeight)) {
+  if (!RankedShapedType::isDynamic(inputHeight) &&
+      !RankedShapedType::isDynamic(weightHeight)) {
     int32_t inputSize = inputHeight + pad[2] + pad[3];
     int32_t filterSize = (weightHeight - 1) * dilation[1] + 1;
     int32_t unstridedResult = inputSize - filterSize + 1;
     outputShape[2] = (unstridedResult - 1) / stride[1] + 1;
   }
 
-  if (!ShapedType::isDynamic(inputWidth) &&
-      !ShapedType::isDynamic(weightWidth)) {
+  if (!RankedShapedType::isDynamic(inputWidth) &&
+      !RankedShapedType::isDynamic(weightWidth)) {
     int32_t inputSize = inputWidth + pad[4] + pad[5];
     int32_t filterSize = (weightWidth - 1) * dilation[2] + 1;
     int32_t unstridedResult = inputSize - filterSize + 1;
     outputShape[3] = (unstridedResult - 1) / stride[2] + 1;
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
LogicalResult MaxPool2dOp::inferReturnTypeComponents(
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   return poolingInferReturnTypes(operands, attributes, inferredReturnShapes);
 }
 
 LogicalResult DepthwiseConv2DOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
-  llvm::SmallVector<int64_t> outputShape(4, ShapedType::kDynamic);
+  llvm::SmallVector<int64_t> outputShape(4, RankedShapedType::kDynamic);
   DepthwiseConv2DOp::Adaptor adaptor(operands.getValues(), attributes);
 
-  int64_t inputWidth = ShapedType::kDynamic;
-  int64_t inputHeight = ShapedType::kDynamic;
-  int64_t inputChannels = ShapedType::kDynamic;
-
-  int64_t weightWidth = ShapedType::kDynamic;
-  int64_t weightHeight = ShapedType::kDynamic;
-  int64_t depthChannels = ShapedType::kDynamic;
+  int64_t inputWidth = RankedShapedType::kDynamic;
+  int64_t inputHeight = RankedShapedType::kDynamic;
+  int64_t inputChannels = RankedShapedType::kDynamic;
+
+  int64_t weightWidth = RankedShapedType::kDynamic;
+  int64_t weightHeight = RankedShapedType::kDynamic;
+  int64_t depthChannels = RankedShapedType::kDynamic;
 
   // Input shape describes input width/height and batch.
   ShapeAdaptor inputShape = operands.getShape(adaptor.getInput());
   if (inputShape.hasRank()) {
     outputShape[0] = inputShape.getDimSize(0);
     inputHeight = inputShape.getDimSize(1);
     inputWidth = inputShape.getDimSize(2);
     inputChannels = inputShape.getDimSize(3);
   }
 
   // Weight shapes describes the filter width/height and the output channels.
   ShapeAdaptor weightShape = operands.getShape(adaptor.getWeight());
   if (weightShape.hasRank()) {
     weightHeight = weightShape.getDimSize(0);
     weightWidth = weightShape.getDimSize(1);
-    inputChannels = ShapedType::isDynamic(inputChannels)
+    inputChannels = RankedShapedType::isDynamic(inputChannels)
                         ? weightShape.getDimSize(2)
                         : inputChannels;
     depthChannels = weightShape.getDimSize(3);
   }
 
   // If both inputChannels and depthChannels are available we can determine
   // the output channels.
-  if (!ShapedType::isDynamic(inputChannels) &&
-      !ShapedType::isDynamic(depthChannels)) {
+  if (!RankedShapedType::isDynamic(inputChannels) &&
+      !RankedShapedType::isDynamic(depthChannels)) {
     outputShape[3] = inputChannels * depthChannels;
   }
 
   // Bias shape can describe the output channels.
   ShapeAdaptor biasShape = operands.getShape(adaptor.getBias());
   if (biasShape.hasRank()) {
-    outputShape[3] = ShapedType::isDynamic(outputShape[3])
+    outputShape[3] = RankedShapedType::isDynamic(outputShape[3])
                          ? biasShape.getDimSize(0)
                          : outputShape[3];
   }
 
   llvm::ArrayRef<int64_t> dilation = adaptor.getDilation();
   llvm::ArrayRef<int64_t> padding = adaptor.getPad();
   llvm::ArrayRef<int64_t> stride = adaptor.getStride();
 
-  if (!ShapedType::isDynamic(inputHeight) &&
-      !ShapedType::isDynamic(weightHeight)) {
+  if (!RankedShapedType::isDynamic(inputHeight) &&
+      !RankedShapedType::isDynamic(weightHeight)) {
     int64_t inputSize = inputHeight + padding[0] + padding[1];
     int64_t filterSize = (weightHeight - 1) * dilation[0] + 1;
     int64_t unstridedResult = inputSize - filterSize + 1;
     outputShape[1] = (unstridedResult - 1) / stride[0] + 1;
   }
 
-  if (!ShapedType::isDynamic(inputWidth) &&
-      !ShapedType::isDynamic(weightWidth)) {
+  if (!RankedShapedType::isDynamic(inputWidth) &&
+      !RankedShapedType::isDynamic(weightWidth)) {
     int64_t inputSize = inputWidth + padding[2] + padding[3];
     int64_t filterSize = (weightWidth - 1) * dilation[1] + 1;
     int64_t unstridedResult = inputSize - filterSize + 1;
     outputShape[2] = (unstridedResult - 1) / stride[1] + 1;
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult DepthwiseConv2DOp::verify() { return verifyConvOp(*this); }
 
 LogicalResult TransposeConv2DOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   TransposeConv2DOp::Adaptor adaptor(operands.getValues(), attributes);
   // outputShape is mutable.
   llvm::SmallVector<int64_t> outputShape =
       convertToMlirShape(adaptor.getOutShape());
 
-  int64_t inputWidth = ShapedType::kDynamic;
-  int64_t inputHeight = ShapedType::kDynamic;
-  int64_t weightWidth = ShapedType::kDynamic;
-  int64_t weightHeight = ShapedType::kDynamic;
+  int64_t inputWidth = RankedShapedType::kDynamic;
+  int64_t inputHeight = RankedShapedType::kDynamic;
+  int64_t weightWidth = RankedShapedType::kDynamic;
+  int64_t weightHeight = RankedShapedType::kDynamic;
 
   // Input shape describes input width/height and batch.
   ShapeAdaptor inputShape = operands.getShape(adaptor.getInput());
   if (inputShape.hasRank()) {
-    outputShape[0] = ShapedType::isDynamic(outputShape[0])
+    outputShape[0] = RankedShapedType::isDynamic(outputShape[0])
                          ? inputShape.getDimSize(0)
                          : outputShape[0];
     inputHeight = inputShape.getDimSize(1);
     inputWidth = inputShape.getDimSize(2);
   }
 
   // Weight shapes describes the filter width/height and the output channels.
   ShapeAdaptor weightShape = operands.getShape(adaptor.getFilter());
   if (weightShape.hasRank()) {
-    outputShape[3] = ShapedType::isDynamic(outputShape[3])
+    outputShape[3] = RankedShapedType::isDynamic(outputShape[3])
                          ? weightShape.getDimSize(0)
                          : outputShape[3];
     weightHeight = weightShape.getDimSize(1);
     weightWidth = weightShape.getDimSize(2);
   }
 
   // Bias shape can describe the output channels.
   ShapeAdaptor biasShape = operands.getShape(adaptor.getInput());
   if (biasShape.hasRank()) {
-    outputShape[3] = ShapedType::isDynamic(outputShape[3])
+    outputShape[3] = RankedShapedType::isDynamic(outputShape[3])
                          ? biasShape.getDimSize(0)
                          : outputShape[3];
   }
 
   llvm::ArrayRef<int64_t> padding = adaptor.getOutPad();
   llvm::ArrayRef<int64_t> stride = adaptor.getStride();
 
-  if (!ShapedType::isDynamic(inputHeight) &&
-      !ShapedType::isDynamic(weightHeight)) {
+  if (!RankedShapedType::isDynamic(inputHeight) &&
+      !RankedShapedType::isDynamic(weightHeight)) {
     int64_t calculateSize =
         (inputHeight - 1) * stride[0] + padding[0] + padding[1] + weightHeight;
-    outputShape[1] =
-        ShapedType::isDynamic(outputShape[1]) ? calculateSize : outputShape[1];
+    outputShape[1] = RankedShapedType::isDynamic(outputShape[1])
+                         ? calculateSize
+                         : outputShape[1];
   }
 
-  if (!ShapedType::isDynamic(inputWidth) &&
-      !ShapedType::isDynamic(weightWidth)) {
+  if (!RankedShapedType::isDynamic(inputWidth) &&
+      !RankedShapedType::isDynamic(weightWidth)) {
     int64_t calculateSize =
         (inputWidth - 1) * stride[1] + padding[2] + padding[3] + weightWidth;
-    outputShape[2] =
-        ShapedType::isDynamic(outputShape[2]) ? calculateSize : outputShape[2];
+    outputShape[2] = RankedShapedType::isDynamic(outputShape[2])
+                         ? calculateSize
+                         : outputShape[2];
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult IfOp::inferReturnTypeComponents(
     MLIRContext *context, ::std::optional<Location> location,

mlir/lib/Dialect/Tosa/Transforms/TosaDecomposeConv2D.cpp

 
 using namespace mlir;
 using namespace mlir::tosa;
 
 namespace {
 
 SmallVector<int64_t> convertFromMlirShape(ArrayRef<int64_t> shape) {
   return to_vector(llvm::map_range(shape, [](int64_t dim) {
-    return ShapedType::isDynamic(dim) ? -1 : dim;
+    return RankedShapedType::isDynamic(dim) ? -1 : dim;
   }));
 }
 
 struct Conv2DIsFullyConnected : public OpRewritePattern<tosa::Conv2DOp> {
   explicit Conv2DIsFullyConnected(MLIRContext *context)
       : OpRewritePattern(context) {}
 
   LogicalResult matchAndRewrite(tosa::Conv2DOp op,
                                 PatternRewriter &rewriter) const override {
     Value input = op.getInput();
     Value weight = op.getWeight();
-    ShapedType inputType = input.getType().cast<ShapedType>();
-    ShapedType weightType = weight.getType().cast<ShapedType>();
-    ShapedType resultType = op.getType().cast<ShapedType>();
+    auto inputType = input.getType().cast<RankedShapedType>();
+    auto weightType = weight.getType().dyn_cast<RankedShapedType>();
+    auto resultType = op.getType().cast<RankedShapedType>();
 
     auto numDynamic =
-        llvm::count_if(inputType.getShape(), ShapedType::isDynamic);
+        llvm::count_if(inputType.getShape(), RankedShapedType::isDynamic);
     if (numDynamic > 1)
       return rewriter.notifyMatchFailure(
           op, "at most one dim in input may be dynamic");
-    if (!weightType.hasRank())
+    if (!weightType)
       return rewriter.notifyMatchFailure(op, "unranked weight input");
 
     if (!llvm::all_of(op.getStride(), [](int64_t v) { return v == 1; }))
       return failure();
 
     // Only works for a 1x1 kernel.
     ArrayRef<int64_t> weightShape = weightType.getShape();
     if (weightShape[1] != 1 || weightShape[2] != 1)
if (llvm::any_of(pad, [](int64_t p) { return p != 0; })) {
               op, "tosa.conv op quantization has zp outside of input range");
 
         zeroAttr = rewriter.getIntegerAttr(inputETy, iZp);
       }
 
       llvm::SmallVector<int64_t> newShape(inputType.getShape());
 
       for (int i = 0, s = newShape.size(); i < s; ++i) {
-        if (newShape[i] != ShapedType::kDynamic) {
+        if (newShape[i] != RankedShapedType::kDynamic) {
           newShape[i] += pad[i * 2] + pad[i * 2 + 1];
         }
       }
 
       auto padSizeTy = RankedTensorType::get({4, 2}, rewriter.getI64Type());
       auto padSize =
           DenseIntElementsAttr::get(padSizeTy, ArrayRef<int64_t>(pad));
       Value padSizeVal =
           rewriter.create<tosa::ConstOp>(op->getLoc(), padSizeTy, padSize);
 
       auto padTy = RankedTensorType::get({}, inputETy);
       auto padAttr = DenseElementsAttr::get(padTy, zeroAttr);
       Value padVal =
           rewriter.create<tosa::ConstOp>(op->getLoc(), padTy, padAttr);
       inputType = RankedTensorType::get(newShape, inputETy);
       input = rewriter.create<tosa::PadOp>(op->getLoc(), inputType, input,
                                            padSizeVal, padVal);
     }
 
     // Reshape input to [N,IH,IW,IC] -> [N * IH * IW, IC].
     ArrayRef<int64_t> inputShape = inputType.getShape();
-    int64_t combined = ShapedType::kDynamic;
+    int64_t combined = RankedShapedType::kDynamic;
     if (numDynamic == 0)
       combined = inputShape[0] * inputShape[1] * inputShape[2];
     llvm::SmallVector<int64_t, 2> revisedInputShape{combined, inputShape[3]};
     auto revisedInputShapeType =
         RankedTensorType::get(revisedInputShape, inputType.getElementType());
     auto reshapedInput = rewriter
                              .create<tosa::ReshapeOp>(
                                  op.getLoc(), revisedInputShapeType, input,

mlir/lib/Dialect/Tosa/Transforms/TosaDecomposeDepthwise.cpp

 struct DepthwiseConv2DIsMul : public OpRewritePattern<tosa::DepthwiseConv2DOp> {
   explicit DepthwiseConv2DIsMul(MLIRContext *context)
       : OpRewritePattern(context) {}
 
   LogicalResult matchAndRewrite(tosa::DepthwiseConv2DOp op,
                                 PatternRewriter &rewriter) const override {
     Value input = op.getInput();
     Value weight = op.getWeight();
-    ShapedType inputType = input.getType().cast<ShapedType>();
-    ShapedType weightType = weight.getType().cast<ShapedType>();
-    ShapedType resultType = op.getOutput().getType().cast<ShapedType>();
+    auto inputType = input.getType().cast<RankedShapedType>();
+    auto weightType = weight.getType().cast<RankedShapedType>();
+    auto resultType = op.getOutput().getType().cast<RankedShapedType>();
 
     if (!(inputType.hasStaticShape() && weightType.hasStaticShape() &&
           resultType.hasStaticShape())) {
       return failure();
     }
 
     if (!llvm::all_of(op.getStride(), [](int64_t v) { return v == 1; }))
       return failure();
for (const auto &it : llvm::enumerate(padAttr))
       pad[it.index() + 2] = it.value();
 
     if (llvm::any_of(pad, [](int64_t p) { return p != 0; })) {
       Type inputETy = inputType.getElementType();
       Attribute zeroAttr = rewriter.getZeroAttr(inputETy);
 
       llvm::SmallVector<int64_t> newShape(inputType.getShape());
       for (int i = 0, s = pad.size(); i < s; ++i) {
-        if (newShape[i / 2] != ShapedType::kDynamic) {
+        if (newShape[i / 2] != RankedShapedType::kDynamic) {
           newShape[i / 2] += pad[i];
         }
       }
 
       auto padSizeTy = RankedTensorType::get({5, 2}, rewriter.getI64Type());
       auto padSize =
           DenseIntElementsAttr::get(padSizeTy, ArrayRef<int64_t>(pad));
       Value padSizeVal =
auto mulShapeType = RankedTensorType::get(
         mulShape,
         weight.getType().dyn_cast<RankedTensorType>().getElementType());
     Value mulValue = rewriter
                          .create<tosa::MulOp>(op.getLoc(), mulShapeType, input,
                                               weight, /*shift=*/0)
                          .getResult();
 
     // Reshape output to [N, H, W, C * M].
-    auto outputShape = op.getOutput().getType().cast<ShapedType>().getShape();
+    auto outputShape =
+        op.getOutput().getType().cast<RankedShapedType>().getShape();
     auto outputShapeType = RankedTensorType::get(
         outputShape,
         input.getType().dyn_cast<RankedTensorType>().getElementType());
     auto outputValue = rewriter.create<tosa::ReshapeOp>(
         op.getLoc(), outputShapeType, mulValue,
         rewriter.getDenseI64ArrayAttr(outputShape));
 
     // Add in the bias.

mlir/lib/Dialect/Tosa/Transforms/TosaDecomposeTransposeConv.cpp

public:
   using OpRewritePattern<tosa::TransposeConv2DOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(tosa::TransposeConv2DOp op,
                                 PatternRewriter &rewriter) const final {
     Location loc = op->getLoc();
     Value input = op->getOperand(0);
     Value weight = op->getOperand(1);
     Value bias = op->getOperand(2);
 
-    ShapedType inputTy = input.getType().cast<ShapedType>();
-    ShapedType weightTy = weight.getType().cast<ShapedType>();
-    ShapedType biasTy = bias.getType().cast<ShapedType>();
-    ShapedType resultTy = op->getResult(0).getType().cast<ShapedType>();
+    auto inputTy = input.getType().dyn_cast<RankedShapedType>();
+    auto weightTy = weight.getType().dyn_cast<RankedShapedType>();
+    auto biasTy = bias.getType().dyn_cast<RankedShapedType>();
+    auto resultTy = op->getResult(0).getType().dyn_cast<RankedShapedType>();
+
+    if (!inputTy || !weightTy || !biasTy || !resultTy)
+      return failure();
 
     llvm::ArrayRef<int64_t> stride = op.getStride();
     llvm::ArrayRef<int64_t> pad = op.getOutPad();
 
     // If striding is all 1 we can modify padding and reverse the kernel along
     // the x/y direction to make it a regular convolution. This is much simpler
     // then handling striding....
     if (llvm::any_of(stride, [](int64_t v) { return v != 1; }))
public:
   using OpRewritePattern<tosa::TransposeConv2DOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(tosa::TransposeConv2DOp op,
                                 PatternRewriter &rewriter) const final {
     Location loc = op->getLoc();
     Value input = op->getOperand(0);
     Value weight = op->getOperand(1);
     Value bias = op->getOperand(2);
 
-    ShapedType inputTy = input.getType().cast<ShapedType>();
-    ShapedType weightTy = weight.getType().cast<ShapedType>();
-    ShapedType biasTy = bias.getType().cast<ShapedType>();
-    ShapedType resultTy = op->getResult(0).getType().cast<ShapedType>();
+    auto inputTy = input.getType().dyn_cast<RankedShapedType>();
+    auto weightTy = weight.getType().dyn_cast<RankedShapedType>();
+    auto biasTy = bias.getType().dyn_cast<RankedShapedType>();
+    auto resultTy = op->getResult(0).getType().dyn_cast<RankedShapedType>();
+
+    if (!inputTy || !weightTy || !biasTy || !resultTy)
+      return failure();
 
     Type inputETy = inputTy.getElementType();
     Type weightETy = weightTy.getElementType();
     Type biasETy = biasTy.getElementType();
     Type resultETy = resultTy.getElementType();
 
     llvm::ArrayRef<int64_t> pad = op.getOutPad();
     llvm::ArrayRef<int64_t> stride = op.getStride();
LogicalResult matchAndRewrite(tosa::TransposeConv2DOp op,
 
     // Collapse the strides and output channels into a single dimension.
     llvm::SmallVector<int64_t, 6> weightReshapeDims1 = {
         outputChannels * stride[0] * stride[1], weightHeight / stride[0],
         weightWidth / stride[1], inputChannels};
     weight = createOpAndInfer<tosa::ReshapeOp>(
         rewriter, loc, UnrankedTensorType::get(weightETy), weight,
         rewriter.getDenseI64ArrayAttr(weightReshapeDims1));
-    ShapedType restridedWeightTy = weight.getType().cast<ShapedType>();
+    auto restridedWeightTy = weight.getType().cast<RankedShapedType>();
 
     weight = createOpAndInfer<tosa::ReverseOp>(
         rewriter, loc, UnrankedTensorType::get(weightETy), weight,
         rewriter.getI64IntegerAttr(1));
     weight = createOpAndInfer<tosa::ReverseOp>(
         rewriter, loc, UnrankedTensorType::get(weightETy), weight,
         rewriter.getI64IntegerAttr(2));
 
if (op.getQuantizationInfo()) {
                    weight, zeroBias,
                    /*pad=*/rewriter.getDenseI64ArrayAttr({0, 0, 0, 0}),
                    /*stride=*/rewriter.getDenseI64ArrayAttr({1, 1}),
                    /*dilation=*/rewriter.getDenseI64ArrayAttr({1, 1}))
                    .getResult();
     }
 
     // Factor the resulting width / height.
-    ShapedType convTy = conv2d.getType().cast<ShapedType>();
+    auto convTy = conv2d.getType().cast<RankedShapedType>();
     Type convETy = convTy.getElementType();
 
     int64_t convHeight = convTy.getDimSize(1);
     int64_t convWidth = convTy.getDimSize(2);
 
     // Factor striding out of the convolution result.
     llvm::SmallVector<int64_t, 6> convReshapeDims0 = {
         batch, convHeight, convWidth, stride[0], stride[1], outputChannels};

mlir/lib/Dialect/Tosa/Transforms/TosaFoldConstantTranspose.cpp

 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 using namespace mlir::tosa;
 
 namespace {
 
 template <typename BaseType>
-DenseElementsAttr transposeType(ElementsAttr attr, ShapedType inputType,
-                                ShapedType outputType,
+DenseElementsAttr transposeType(ElementsAttr attr, RankedShapedType inputType,
+                                RankedShapedType outputType,
                                 llvm::ArrayRef<int64_t> permValues) {
   if (inputType.getNumElements() == 0)
     return DenseElementsAttr::get(outputType, llvm::ArrayRef<BaseType>{});
 
   auto attrValues = attr.getValues<BaseType>();
   auto inputShape = inputType.getShape();
 
   // The inverted permutation map and strides of the output are used to compute

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

Type mlir::tosa::buildQTypeFromMinMax(OpBuilder builder, Type inputDType,
   }
 
   if (min.size() == max.size()) {
     if (min.size() == 1) { // Per-tensor quantization with one min/max pair.
       retType = quant::fakeQuantAttrsToType(
           builder.getUnknownLoc(), quantBits.getInt(), min[0], max[0],
           narrowRange.getValue(), convfunc.expressedType, isSigned);
     } else if (min.size() > 1) { // Per-axis quant on filterQuantDim.
-      auto shape = inputDType.dyn_cast<ShapedType>();
+      auto shape = inputDType.dyn_cast<RankedShapedType>();
       if (!shape)
         return {};
       if ((filterQuantDim) >= 0 && (shape.getRank() > filterQuantDim)) {
         retType = quant::fakeQuantAttrsToType(
             builder.getUnknownLoc(), quantBits.getInt(), filterQuantDim, min[0],
             max[0], narrowRange.getValue(), convfunc.expressedType, isSigned);
       }
     } else {

mlir/lib/Dialect/Traits.cpp

for (size_t i = 0; i != maxRank; ++i) {
     for (ArrayRef<int64_t> extent : shapes) {
       int64_t dim = i >= extent.size() ? 1 : extent[extent.size() - i - 1];
 
       if (dim == 1)
         continue;
 
       // Dimensions are compatible when
       //.  1. One is dynamic, the rest are 1
-      if (ShapedType::isDynamic(dim)) {
+      if (RankedShapedType::isDynamic(dim)) {
         if (seenDynamic || nonOneDim)
           return false;
         seenDynamic = true;
       }
 
       //   2. All are 1 or a specific constant.
       if (nonOneDim && dim != *nonOneDim)
         return false;
bool OpTrait::util::getBroadcastedShape(ArrayRef<int64_t> shape1,
   }
 
   auto i1 = shape1.rbegin(), e1 = shape1.rend();
   auto i2 = shape2.rbegin(), e2 = shape2.rend();
   auto iR = resultShape.rbegin();
 
   // Check each dimension is consistent.
   for (; i1 != e1 && i2 != e2; ++i1, ++i2, ++iR) {
-    if (ShapedType::isDynamic(*i1) || ShapedType::isDynamic(*i2)) {
+    if (RankedShapedType::isDynamic(*i1) || RankedShapedType::isDynamic(*i2)) {
       // One or both dimensions is unknown. Follow TensorFlow behavior:
       // - If either dimension is greater than 1, we assume that the program is
       //   correct, and the other dimension will be broadcast to match it.
       // - If either dimension is 1, the other dimension is the output.
       if (*i1 > 1) {
         *iR = *i1;
       } else if (*i2 > 1) {
         *iR = *i2;
       } else if (*i1 == 1) {
         *iR = *i2;
       } else if (*i2 == 1) {
         *iR = *i1;
       } else {
-        *iR = ShapedType::kDynamic;
+        *iR = RankedShapedType::kDynamic;
       }
     } else {
       if (*i1 == *i2 || *i2 == 1) {
         *iR = *i1;
       } else if (*i1 == 1) {
         *iR = *i2;
       } else {
         // This dimension of the two operand types is incompatible.
         resultShape.clear();
         return false;
       }
     }
   }
 
   return true;
 }
 
 /// Returns the shape of the given type. Scalars will be considered as having a
 /// shape with zero dimensions.
 static ArrayRef<int64_t> getShape(Type type) {
-  if (auto sType = type.dyn_cast<ShapedType>())
+  if (auto sType = type.dyn_cast<RankedShapedType>())
     return sType.getShape();
   return {};
 }
 
 /// Returns the result broadcast composition type from the two given types by
 /// following NumPy broadcast semantics. Returned type may have dynamic shape if
 /// either of the input types has dynamic shape. Returns null type if the two
 /// given types are not broadcast-compatible.

 
 static bool isCompatibleInferredReturnShape(ArrayRef<int64_t> inferred,
                                             ArrayRef<int64_t> existing) {
   auto isCompatible = [](int64_t dim1, int64_t dim2) {
     // If the inferred and existing dim is the same, or one of them is unknown
     // then it is compatible, else if the inferred dim is 1 then it is also
     // compatible. But if the existing dim is 1 and the inferred is greater than
     // 1 then flag.
-    return dim1 == dim2 || ShapedType::isDynamic(dim1) ||
-           ShapedType::isDynamic(dim2) || dim1 == 1;
+    return dim1 == dim2 || RankedShapedType::isDynamic(dim1) ||
+           RankedShapedType::isDynamic(dim2) || dim1 == 1;
   };
   if (inferred.size() != existing.size())
     return false;
   for (auto p : llvm::zip(inferred, existing))
     if (!isCompatible(std::get<0>(p), std::get<1>(p)))
       return false;
   return true;
 }
 
 static std::string getShapeString(ArrayRef<int64_t> shape) {
   // TODO: should replace with printing shape more uniformly across here and
   // when in type.
   std::string ret;
   llvm::raw_string_ostream ss(ret);
   ss << '\'';
   llvm::interleave(
       shape, ss,
       [&](int64_t dim) {
-        if (ShapedType::isDynamic(dim))
+        if (RankedShapedType::isDynamic(dim))
           ss << '?';
         else
           ss << dim;
       },
       "x");
   ss << '\'';
   return ss.str();
 }

mlir/lib/Dialect/Utils/ReshapeOpsUtils.cpp

 #include "mlir/IR/Builders.h"
 
 #include <numeric>
 #include <optional>
 
 using namespace mlir;
 
 std::optional<SmallVector<ReassociationIndices>>
-mlir::getReassociationIndicesForReshape(ShapedType sourceType,
-                                        ShapedType targetType) {
+mlir::getReassociationIndicesForReshape(RankedShapedType sourceType,
+                                        RankedShapedType targetType) {
   if (sourceType.getRank() > targetType.getRank())
     return getReassociationIndicesForCollapse(sourceType.getShape(),
                                               targetType.getShape());
   if (sourceType.getRank() < targetType.getRank())
     return getReassociationIndicesForCollapse(targetType.getShape(),
                                               sourceType.getShape());
   return std::nullopt;
 }
while (sourceDim < sourceShape.size()) {
     unsigned targetDim = reassociationMap.size();
     // If we have mapped all the target dimensions stop and handle the remaining
     // tail of size-1 dimensions explictly.
     if (targetDim == targetShape.size())
       break;
 
     int64_t currTargetShape = targetShape[targetDim];
     while (sourceDim < sourceShape.size() &&
-           sourceShape[sourceDim] != ShapedType::kDynamic &&
+           sourceShape[sourceDim] != RankedShapedType::kDynamic &&
            prodOfCollapsedDims * sourceShape[sourceDim] < currTargetShape) {
       prodOfCollapsedDims *= sourceShape[sourceDim];
       currIndices.push_back(sourceDim++);
     }
 
     // If the current expanded dimension is dynamic, then the collapsed
     // dimensions should also be dynamic and product of all previous unprocessed
     // dimensions of the expanded shape should be 1.
-    if (sourceShape[sourceDim] == ShapedType::kDynamic &&
-        (currTargetShape != ShapedType::kDynamic || prodOfCollapsedDims != 1))
+    if (sourceShape[sourceDim] == RankedShapedType::kDynamic &&
+        (currTargetShape != RankedShapedType::kDynamic ||
+         prodOfCollapsedDims != 1))
       return std::nullopt;
 
     // If the collapsed dim is dynamic, the current expanded dim should also
     // be dynamic.
-    if (currTargetShape == ShapedType::kDynamic &&
-        sourceShape[sourceDim] != ShapedType::kDynamic)
+    if (currTargetShape == RankedShapedType::kDynamic &&
+        sourceShape[sourceDim] != RankedShapedType::kDynamic)
       return std::nullopt;
 
     // For static shapes, if the product of dimensions of the expanded shape
     // should match the collapsed dimension shape.
     if (prodOfCollapsedDims * sourceShape[sourceDim] != currTargetShape)
       return std::nullopt;
 
     currIndices.push_back(sourceDim++);
     reassociationMap.emplace_back(ReassociationIndices{});
     std::swap(reassociationMap.back(), currIndices);
     prodOfCollapsedDims = 1;
   }
   // All the dimensions in the target must have been processed.
   if (reassociationMap.size() != targetShape.size())
     return std::nullopt;
   // Process any remaining entries in the source shape. They all need to be
   // 1 or dynamic.
   for (; sourceDim < sourceShape.size(); sourceDim++) {
-    if (sourceShape[sourceDim] != ShapedType::kDynamic &&
+    if (sourceShape[sourceDim] != RankedShapedType::kDynamic &&
         sourceShape[sourceDim] != 1)
       return std::nullopt;
     // The map is empty when the target type is a scalar.
     if (!reassociationMap.empty())
       reassociationMap.back().push_back(sourceDim);
   }
   return reassociationMap;
 }
LogicalResult mlir::reshapeLikeShapesAreCompatible(
     ArrayRef<int64_t> collapsedShape, ArrayRef<int64_t> expandedShape,
     ArrayRef<ReassociationIndices> reassociationMaps, bool isExpandingReshape) {
   unsigned expandedDimStart = 0;
   for (const auto &map : llvm::enumerate(reassociationMaps)) {
     std::optional<int64_t> dynamicShape;
     int64_t linearizedStaticShape = 1;
     for (const auto &dim : llvm::enumerate(
              expandedShape.slice(expandedDimStart, map.value().size()))) {
-      if (ShapedType::isDynamic(dim.value())) {
+      if (RankedShapedType::isDynamic(dim.value())) {
         if (isExpandingReshape && dynamicShape) {
           return emitError("invalid to have a single dimension (" +
                            Twine(map.index()) +
                            ") expanded into multiple dynamic dims (" +
                            Twine(expandedDimStart + dynamicShape.value()) +
                            "," + Twine(expandedDimStart + dim.index()) + ")");
         }
         dynamicShape = dim.index();
       } else {
         linearizedStaticShape *= dim.value();
       }
     }
     if (dynamicShape) {
-      if (!ShapedType::isDynamic(collapsedShape[map.index()])) {
+      if (!RankedShapedType::isDynamic(collapsedShape[map.index()])) {
         return emitError(
             "expected dimension " + Twine(map.index()) +
             " of collapsed type to be dynamic since one or more of the "
             "corresponding dimensions in the expanded type is dynamic");
       }
     } else {
       if (collapsedShape[map.index()] != linearizedStaticShape) {
         return emitError("expected dimension " + Twine(map.index()) +

mlir/lib/Dialect/Utils/StaticValueUtils.cpp

void dispatchIndexOpFoldResult(OpFoldResult ofr,
                                SmallVectorImpl<int64_t> &staticVec) {
   auto v = ofr.dyn_cast<Value>();
   if (!v) {
     APInt apInt = ofr.get<Attribute>().cast<IntegerAttr>().getValue();
     staticVec.push_back(apInt.getSExtValue());
     return;
   }
   dynamicVec.push_back(v);
-  staticVec.push_back(ShapedType::kDynamic);
+  staticVec.push_back(RankedShapedType::kDynamic);
 }
 
 void dispatchIndexOpFoldResults(ArrayRef<OpFoldResult> ofrs,
                                 SmallVectorImpl<Value> &dynamicVec,
                                 SmallVectorImpl<int64_t> &staticVec) {
   for (OpFoldResult ofr : ofrs)
     dispatchIndexOpFoldResult(ofr, dynamicVec, staticVec);
 }
if (ofrs1.size() != ofrs2.size())
     return false;
   for (auto [ofr1, ofr2] : llvm::zip_equal(ofrs1, ofrs2))
     if (!isEqualConstantIntOrValue(ofr1, ofr2))
       return false;
   return true;
 }
 
 /// Return a vector of OpFoldResults with the same size a staticValues, but all
-/// elements for which ShapedType::isDynamic is true, will be replaced by
+/// elements for which RankedShapedType::isDynamic is true, will be replaced by
 /// dynamicValues.
 SmallVector<OpFoldResult> getMixedValues(ArrayRef<int64_t> staticValues,
                                          ValueRange dynamicValues, Builder &b) {
   SmallVector<OpFoldResult> res;
   res.reserve(staticValues.size());
   unsigned numDynamic = 0;
   unsigned count = static_cast<unsigned>(staticValues.size());
   for (unsigned idx = 0; idx < count; ++idx) {
     int64_t value = staticValues[idx];
-    res.push_back(ShapedType::isDynamic(value)
+    res.push_back(RankedShapedType::isDynamic(value)
                       ? OpFoldResult{dynamicValues[numDynamic++]}
                       : OpFoldResult{b.getI64IntegerAttr(staticValues[idx])});
   }
   return res;
 }
 
 /// Decompose a vector of mixed static or dynamic values into the corresponding
 /// pair of arrays. This is the inverse function of `getMixedValues`.
 std::pair<ArrayAttr, SmallVector<Value>>
 decomposeMixedValues(Builder &b,
                      const SmallVectorImpl<OpFoldResult> &mixedValues) {
   SmallVector<int64_t> staticValues;
   SmallVector<Value> dynamicValues;
   for (const auto &it : mixedValues) {
     if (it.is<Attribute>()) {
       staticValues.push_back(it.get<Attribute>().cast<IntegerAttr>().getInt());
     } else {
-      staticValues.push_back(ShapedType::kDynamic);
+      staticValues.push_back(RankedShapedType::kDynamic);
       dynamicValues.push_back(it.get<Value>());
     }
   }
   return {b.getI64ArrayAttr(staticValues), dynamicValues};
 }
 
 /// Helper to sort `values` according to matching `keys`.
 template <typename K, typename V>

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

 /// return true for memrefs with no strides.
 bool mlir::vector::isLastMemrefDimUnitStride(MemRefType type) {
   int64_t offset;
   SmallVector<int64_t> strides;
   auto successStrides = getStridesAndOffset(type, strides, offset);
   return succeeded(successStrides) && (strides.empty() || strides.back() == 1);
 }
 
-AffineMap mlir::vector::getTransferMinorIdentityMap(ShapedType shapedType,
+AffineMap mlir::vector::getTransferMinorIdentityMap(RankedShapedType shapedType,
                                                     VectorType vectorType) {
   int64_t elementVectorRank = 0;
   VectorType elementVectorType =
       shapedType.getElementType().dyn_cast<VectorType>();
   if (elementVectorType)
     elementVectorRank += elementVectorType.getRank();
   // 0-d transfers are to/from tensor<t>/memref<t> and vector<1xt>.
   // TODO: replace once we have 0-d vectors.

 Type ContractionOp::getExpectedMaskType() {
   auto indexingMaps = this->getIndexingMapsArray();
   AffineMap lhsIdxMap = indexingMaps[0];
   AffineMap rhsIdxMap = indexingMaps[1];
   VectorType lhsType = this->getLhsType();
   VectorType rhsType = this->getRhsType();
 
   unsigned numVecDims = lhsIdxMap.getNumDims();
-  SmallVector<int64_t> maskShape(numVecDims, ShapedType::kDynamic);
+  SmallVector<int64_t> maskShape(numVecDims, RankedShapedType::kDynamic);
 
   // Using the information in the indexing maps, extract the size of each
   // dimension in the vector.contract operation from the two input operands.
   for (auto [dimIdx, dimSize] : llvm::enumerate(lhsType.getShape()))
     maskShape[lhsIdxMap.getDimPosition(dimIdx)] = dimSize;
   for (auto [dimIdx, dimSize] : llvm::enumerate(rhsType.getShape()))
     maskShape[rhsIdxMap.getDimPosition(dimIdx)] = dimSize;
 
-  assert(!ShapedType::isDynamicShape(maskShape) &&
+  assert(!RankedShapedType::isDynamicShape(maskShape) &&
          "Mask shape couldn't be computed");
 
   return VectorType::get(maskShape,
                          IntegerType::get(lhsType.getContext(), /*width=*/1));
 }
 
 SmallVector<StringRef> ContractionOp::getTraitAttrNames() {
   return SmallVector<StringRef>{getIndexingMapsAttrName(),
if (seen[dim.getPosition()]) {
           "used more than once)");
     }
     seen[dim.getPosition()] = true;
   }
   return success();
 }
 
 static LogicalResult
-verifyTransferOp(VectorTransferOpInterface op, ShapedType shapedType,
+verifyTransferOp(VectorTransferOpInterface op, RankedShapedType shapedType,
                  VectorType vectorType, VectorType maskType,
                  VectorType inferredMaskType, AffineMap permutationMap,
                  ArrayAttr inBounds) {
   if (op->hasAttr("masked")) {
     return op->emitOpError("masked attribute has been removed. "
                            "Use in_bounds instead.");
   }
 
result.addAttribute(TransferReadOp::getOperandSegmentSizeAttr(),
                       builder.getDenseI32ArrayAttr(
                           {1, static_cast<int32_t>(indexInfo.size()), 1,
                            static_cast<int32_t>(hasMask.succeeded())}));
   return parser.addTypeToList(vectorType, result.types);
 }
 
 LogicalResult TransferReadOp::verify() {
   // Consistency of elemental types in source and vector.
-  ShapedType shapedType = getShapedType();
+  RankedShapedType shapedType = getShapedType();
   VectorType vectorType = getVectorType();
   VectorType maskType = getMaskType();
   auto paddingType = getPadding().getType();
   auto permutationMap = getPermutationMap();
   VectorType inferredMaskType =
       maskType ? inferTransferOpMaskType(vectorType, permutationMap)
                : VectorType();
   auto sourceElementType = shapedType.getElementType();
void TransferWriteOp::print(OpAsmPrinter &p) {
   if (getMask())
     p << ", " << getMask();
   printTransferAttrs(p, *this);
   p << " : " << getVectorType() << ", " << getShapedType();
 }
 
 LogicalResult TransferWriteOp::verify() {
   // Consistency of elemental types in shape and vector.
-  ShapedType shapedType = getShapedType();
+  RankedShapedType shapedType = getShapedType();
   VectorType vectorType = getVectorType();
   VectorType maskType = getMaskType();
   auto permutationMap = getPermutationMap();
   VectorType inferredMaskType =
       maskType ? inferTransferOpMaskType(vectorType, permutationMap)
                : VectorType();
 
   if (llvm::size(getIndices()) != shapedType.getRank())

 //===----------------------------------------------------------------------===//
 // GatherOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult GatherOp::verify() {
   VectorType indVType = getIndexVectorType();
   VectorType maskVType = getMaskVectorType();
   VectorType resVType = getVectorType();
-  ShapedType baseType = getBaseType();
+  RankedShapedType baseType = getBaseType();
 
   if (!baseType.isa<MemRefType, RankedTensorType>())
     return emitOpError("requires base to be a memref or ranked tensor type");
 
   if (resVType.getElementType() != baseType.getElementType())
     return emitOpError("base and result element type should match");
   if (llvm::size(getIndices()) != baseType.getRank())
     return emitOpError("requires ") << baseType.getRank() << " indices";

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

LogicalResult matchAndRewrite(vector::MultiDimReductionOp multiReductionOp,
 
     /// vector.extract(vector.multi_reduce(vector.shape_cast(v, 1xk)), 0)
     Value cast = rewriter.create<vector::ShapeCastOp>(
         loc, castedType, multiReductionOp.getSource());
     Value castAcc = rewriter.create<vector::BroadcastOp>(
         loc, accType, multiReductionOp.getAcc());
     Value castMask;
     if (maskableOp.isMasked()) {
-      auto maskType = mask.getType().cast<ShapedType>();
+      auto maskType = mask.getType().cast<RankedShapedType>();
       auto castMaskType =
           VectorType::get(ArrayRef<int64_t>{1, maskType.getShape().back()},
                           maskType.getElementType());
       castMask = rewriter.create<vector::BroadcastOp>(loc, castMaskType, mask);
     }
 
     Operation *newOp = rewriter.create<vector::MultiDimReductionOp>(
         loc, cast, castAcc, reductionMask, multiReductionOp.getKind());

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

LogicalResult matchAndRewrite(vector::TransposeOp op,
     auto prunedInStrides = computeStrides(prunedInShape);
 
     // Generates the extract/insert operations for every scalar/vector element
     // of the leftmost transposed dimensions. We traverse every transpose
     // element using a linearized index that we delinearize to generate the
     // appropriate indices for the extract/insert operations.
     Value result = rewriter.create<arith::ConstantOp>(
         loc, resType, rewriter.getZeroAttr(resType));
-    int64_t numTransposedElements = ShapedType::getNumElements(prunedInShape);
+    int64_t numTransposedElements =
+        RankedShapedType::getNumElements(prunedInShape);
 
     for (int64_t linearIdx = 0; linearIdx < numTransposedElements;
          ++linearIdx) {
       auto extractIdxs = delinearize(linearIdx, prunedInStrides);
       SmallVector<int64_t> insertIdxs(extractIdxs);
       applyPermutationToVector(insertIdxs, prunedTransp);
       Value extractOp =
           rewriter.create<vector::ExtractOp>(loc, input, extractIdxs);

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

static int64_t hasMatchingInnerContigousShape(MemRefType memrefType,
   }
   return true;
 }
 
 /// Creates a memref.collapse_shape collapsing all inner dimensions of the
 /// input starting at `firstDimToCollapse`.
 static Value collapseInnerDims(PatternRewriter &rewriter, mlir::Location loc,
                                Value input, int64_t firstDimToCollapse) {
-  ShapedType inputType = input.getType().cast<ShapedType>();
+  auto inputType = input.getType().cast<RankedShapedType>();
   if (inputType.getRank() == 1)
     return input;
   SmallVector<ReassociationIndices> reassociation;
   for (int64_t i = 0; i < firstDimToCollapse; ++i)
     reassociation.push_back(ReassociationIndices{i});
   ReassociationIndices collapsedIndices;
   for (int64_t i = firstDimToCollapse; i < inputType.getRank(); ++i)
     collapsedIndices.push_back(i);

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

if (failed(getStridesAndOffset(aT, aStrides, aOffset)) ||
     return MemRefType();
 
   ArrayRef<int64_t> aShape = aT.getShape(), bShape = bT.getShape();
   int64_t resOffset;
   SmallVector<int64_t, 4> resShape(aT.getRank(), 0),
       resStrides(bT.getRank(), 0);
   for (int64_t idx = 0, e = aT.getRank(); idx < e; ++idx) {
     resShape[idx] =
-        (aShape[idx] == bShape[idx]) ? aShape[idx] : ShapedType::kDynamic;
-    resStrides[idx] =
-        (aStrides[idx] == bStrides[idx]) ? aStrides[idx] : ShapedType::kDynamic;
+        (aShape[idx] == bShape[idx]) ? aShape[idx] : RankedShapedType::kDynamic;
+    resStrides[idx] = (aStrides[idx] == bStrides[idx])
+                          ? aStrides[idx]
+                          : RankedShapedType::kDynamic;
   }
-  resOffset = (aOffset == bOffset) ? aOffset : ShapedType::kDynamic;
+  resOffset = (aOffset == bOffset) ? aOffset : RankedShapedType::kDynamic;
   return MemRefType::get(
       resShape, aT.getElementType(),
       StridedLayoutAttr::get(aT.getContext(), resOffset, resStrides));
 }
 
 /// Operates under a scoped context to build the intersection between the
 /// view `xferOp.source()` @ `xferOp.indices()` and the view `alloc`.
 // TODO: view intersection/union/differences should be a proper std op.

mlir/lib/IR/AsmPrinter.cpp

static void printDenseIntElement(const APInt &value, raw_ostream &os,
                                  Type type) {
   if (type.isInteger(1))
     os << (value.getBoolValue() ? "true" : "false");
   else
     value.print(os, !type.isUnsignedInteger());
 }
 
 static void
-printDenseElementsAttrImpl(bool isSplat, ShapedType type, raw_ostream &os,
+printDenseElementsAttrImpl(bool isSplat, RankedShapedType type, raw_ostream &os,
                            function_ref<void(unsigned)> printEltFn) {
   // Special case for 0-d and splat tensors.
   if (isSplat)
     return printEltFn(0);
 
   // Special case for degenerate tensors.
   auto numElements = type.getNumElements();
   if (numElements == 0)
TypeSwitch<Type>(type)
           os << vShape[dimIdx] << "]x";
         }
         printType(vectorTy.getElementType());
         os << '>';
       })
       .Case<RankedTensorType>([&](RankedTensorType tensorTy) {
         os << "tensor<";
         for (int64_t dim : tensorTy.getShape()) {
-          if (ShapedType::isDynamic(dim))
+          if (RankedShapedType::isDynamic(dim))
             os << '?';
           else
             os << dim;
           os << 'x';
         }
         printType(tensorTy.getElementType());
         // Only print the encoding attribute value if set.
         if (tensorTy.getEncoding()) {
           os << ", ";
           printAttribute(tensorTy.getEncoding());
         }
         os << '>';
       })
       .Case<UnrankedTensorType>([&](UnrankedTensorType tensorTy) {
         os << "tensor<*x";
         printType(tensorTy.getElementType());
         os << '>';
       })
       .Case<MemRefType>([&](MemRefType memrefTy) {
         os << "memref<";
         for (int64_t dim : memrefTy.getShape()) {
-          if (ShapedType::isDynamic(dim))
+          if (RankedShapedType::isDynamic(dim))
             os << '?';
           else
             os << dim;
           os << 'x';
         }
         printType(memrefTy.getElementType());
         MemRefLayoutAttrInterface layout = memrefTy.getLayout();
         if (!layout.isa<AffineMapAttr>() || !layout.isIdentity()) {

mlir/lib/IR/AttributeDetail.h

struct DenseIntOrFPElementsAttrStorage : public DenseElementsAttributeStorage {
   bool operator==(const KeyTy &key) const {
     return key.type == type && key.data == data;
   }
 
   /// Construct a key from a shaped type, raw data buffer, and a flag that
   /// signals if the data is already known to be a splat. Callers to this
   /// function are expected to tag preknown splat values when possible, e.g. one
   /// element shapes.
-  static KeyTy getKey(ShapedType ty, ArrayRef<char> data, bool isKnownSplat) {
+  static KeyTy getKey(RankedShapedType ty, ArrayRef<char> data,
+                      bool isKnownSplat) {
     // Handle an empty storage instance.
     if (data.empty())
       return KeyTy(ty, data, 0);
 
     // If the data is already known to be a splat, the key hash value is
     // directly the data buffer.
     bool isBoolData = ty.getElementType().isInteger(1);
     if (isKnownSplat) {
bool operator==(const KeyTy &key) const {
     // by contents.
     return key.data == data;
   }
 
   /// Construct a key from a shaped type, StringRef data buffer, and a flag that
   /// signals if the data is already known to be a splat. Callers to this
   /// function are expected to tag preknown splat values when possible, e.g. one
   /// element shapes.
-  static KeyTy getKey(ShapedType ty, ArrayRef<StringRef> data,
+  static KeyTy getKey(RankedShapedType ty, ArrayRef<StringRef> data,
                       bool isKnownSplat) {
     // Handle an empty storage instance.
     if (data.empty())
       return KeyTy(ty, data, 0);
 
     // If the data is already known to be a splat, the key hash value is
     // directly the data buffer.
     if (isKnownSplat)

mlir/lib/IR/BuiltinAttributeInterfaces.cpp

 Type ElementsAttr::getElementType(ElementsAttr elementsAttr) {
   return elementsAttr.getType().getElementType();
 }
 
 int64_t ElementsAttr::getNumElements(ElementsAttr elementsAttr) {
   return elementsAttr.getType().getNumElements();
 }
 
-bool ElementsAttr::isValidIndex(ShapedType type, ArrayRef<uint64_t> index) {
+bool ElementsAttr::isValidIndex(RankedShapedType type,
+                                ArrayRef<uint64_t> index) {
   // Verify that the rank of the indices matches the held type.
   int64_t rank = type.getRank();
   if (rank == 0 && index.size() == 1 && index[0] == 0)
     return true;
   if (rank != static_cast<int64_t>(index.size()))
     return false;
 
   // Verify that all of the indices are within the shape dimensions.
   ArrayRef<int64_t> shape = type.getShape();
   return llvm::all_of(llvm::seq<int>(0, rank), [&](int i) {
     int64_t dim = static_cast<int64_t>(index[i]);
     return 0 <= dim && dim < shape[i];
   });
 }
 bool ElementsAttr::isValidIndex(ElementsAttr elementsAttr,
                                 ArrayRef<uint64_t> index) {
   return isValidIndex(elementsAttr.getType(), index);
 }
 
 uint64_t ElementsAttr::getFlattenedIndex(Type type, ArrayRef<uint64_t> index) {
-  ShapedType shapeType = type.cast<ShapedType>();
+  RankedShapedType shapeType = type.cast<RankedShapedType>();
   assert(isValidIndex(shapeType, index) &&
          "expected valid multi-dimensional index");
 
   // Reduce the provided multidimensional index into a flattended 1D row-major
   // index.
   auto rank = shapeType.getRank();
   ArrayRef<int64_t> shape = shapeType.getShape();
   uint64_t valueIndex = 0;

mlir/lib/IR/BuiltinAttributes.cpp

 
 //===----------------------------------------------------------------------===//
 // StridedLayoutAttr
 //===----------------------------------------------------------------------===//
 
 /// Prints a strided layout attribute.
 void StridedLayoutAttr::print(llvm::raw_ostream &os) const {
   auto printIntOrQuestion = [&](int64_t value) {
-    if (ShapedType::isDynamic(value))
+    if (RankedShapedType::isDynamic(value))
       os << "?";
     else
       os << value;
   };
 
   os << "strided<[";
   llvm::interleaveComma(getStrides(), os, printIntOrQuestion);
   os << "]";
std::copy_n(rawData + (bitPos / CHAR_BIT),
                     reinterpret_cast<const char *>(result.getRawData())));
   }
   return result;
 }
 
 /// Returns true if 'values' corresponds to a splat, i.e. one element, or has
 /// the same element count as 'type'.
 template <typename Values>
-static bool hasSameElementsOrSplat(ShapedType type, const Values &values) {
+static bool hasSameElementsOrSplat(RankedShapedType type,
+                                   const Values &values) {
   return (values.size() == 1) ||
          (type.getNumElements() == static_cast<int64_t>(values.size()));
 }
 
 //===----------------------------------------------------------------------===//
 // DenseElementsAttr Iterators
 //===----------------------------------------------------------------------===//
 

 // DenseElementsAttr
 //===----------------------------------------------------------------------===//
 
 /// Method for support type inquiry through isa, cast and dyn_cast.
 bool DenseElementsAttr::classof(Attribute attr) {
   return attr.isa<DenseIntOrFPElementsAttr, DenseStringElementsAttr>();
 }
 
-DenseElementsAttr DenseElementsAttr::get(ShapedType type,
+DenseElementsAttr DenseElementsAttr::get(RankedShapedType type,
                                          ArrayRef<Attribute> values) {
   assert(hasSameElementsOrSplat(type, values));
 
   Type eltType = type.getElementType();
 
   // Take care complex type case first.
   if (auto complexType = eltType.dyn_cast<ComplexType>()) {
     if (complexType.getElementType().isIntOrIndex()) {
DenseElementsAttr DenseElementsAttr::get(RankedShapedType type,
 
   // Handle the special encoding of splat of bool.
   if (values.size() == 1 && eltType.isInteger(1))
     data[0] = data[0] ? -1 : 0;
 
   return DenseIntOrFPElementsAttr::getRaw(type, data);
 }
 
-DenseElementsAttr DenseElementsAttr::get(ShapedType type,
+DenseElementsAttr DenseElementsAttr::get(RankedShapedType type,
                                          ArrayRef<bool> values) {
   assert(hasSameElementsOrSplat(type, values));
   assert(type.getElementType().isInteger(1));
 
   std::vector<char> buff(llvm::divideCeil(values.size(), CHAR_BIT));
 
   if (!values.empty()) {
     bool isSplat = true;
     bool firstValue = values[0];
     for (int i = 0, e = values.size(); i != e; ++i) {
       isSplat &= values[i] == firstValue;
       setBit(buff.data(), i, values[i]);
     }
 
     // Splat of bool is encoded as a byte with all-ones in it.
     if (isSplat) {
       buff.resize(1);
       buff[0] = values[0] ? -1 : 0;
     }
   }
 
   return DenseIntOrFPElementsAttr::getRaw(type, buff);
 }
 
-DenseElementsAttr DenseElementsAttr::get(ShapedType type,
+DenseElementsAttr DenseElementsAttr::get(RankedShapedType type,
                                          ArrayRef<StringRef> values) {
   assert(!type.getElementType().isIntOrFloat());
   return DenseStringElementsAttr::get(type, values);
 }
 
 /// Constructs a dense integer elements attribute from an array of APInt
 /// values. Each APInt value is expected to have the same bitwidth as the
 /// element type of 'type'.
-DenseElementsAttr DenseElementsAttr::get(ShapedType type,
+DenseElementsAttr DenseElementsAttr::get(RankedShapedType type,
                                          ArrayRef<APInt> values) {
   assert(type.getElementType().isIntOrIndex());
   assert(hasSameElementsOrSplat(type, values));
   size_t storageBitWidth = getDenseElementStorageWidth(type.getElementType());
   return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, values);
 }
-DenseElementsAttr DenseElementsAttr::get(ShapedType type,
+DenseElementsAttr DenseElementsAttr::get(RankedShapedType type,
                                          ArrayRef<std::complex<APInt>> values) {
   ComplexType complex = type.getElementType().cast<ComplexType>();
   assert(complex.getElementType().isa<IntegerType>());
   assert(hasSameElementsOrSplat(type, values));
   size_t storageBitWidth = getDenseElementStorageWidth(complex) / 2;
   ArrayRef<APInt> intVals(reinterpret_cast<const APInt *>(values.data()),
                           values.size() * 2);
   return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, intVals);
 }
 
 // Constructs a dense float elements attribute from an array of APFloat
 // values. Each APFloat value is expected to have the same bitwidth as the
 // element type of 'type'.
-DenseElementsAttr DenseElementsAttr::get(ShapedType type,
+DenseElementsAttr DenseElementsAttr::get(RankedShapedType type,
                                          ArrayRef<APFloat> values) {
   assert(type.getElementType().isa<FloatType>());
   assert(hasSameElementsOrSplat(type, values));
   size_t storageBitWidth = getDenseElementStorageWidth(type.getElementType());
   return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, values);
 }
 DenseElementsAttr
-DenseElementsAttr::get(ShapedType type,
+DenseElementsAttr::get(RankedShapedType type,
                        ArrayRef<std::complex<APFloat>> values) {
   ComplexType complex = type.getElementType().cast<ComplexType>();
   assert(complex.getElementType().isa<FloatType>());
   assert(hasSameElementsOrSplat(type, values));
   ArrayRef<APFloat> apVals(reinterpret_cast<const APFloat *>(values.data()),
                            values.size() * 2);
   size_t storageBitWidth = getDenseElementStorageWidth(complex) / 2;
   return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, apVals);
 }
 
 /// Construct a dense elements attribute from a raw buffer representing the
 /// data for this attribute. Users should generally not use this methods as
 /// the expected buffer format may not be a form the user expects.
 DenseElementsAttr
-DenseElementsAttr::getFromRawBuffer(ShapedType type, ArrayRef<char> rawBuffer) {
+DenseElementsAttr::getFromRawBuffer(RankedShapedType type,
+                                    ArrayRef<char> rawBuffer) {
   return DenseIntOrFPElementsAttr::getRaw(type, rawBuffer);
 }
 
 /// Returns true if the given buffer is a valid raw buffer for the given type.
-bool DenseElementsAttr::isValidRawBuffer(ShapedType type,
+bool DenseElementsAttr::isValidRawBuffer(RankedShapedType type,
                                          ArrayRef<char> rawBuffer,
                                          bool &detectedSplat) {
   size_t storageWidth = getDenseElementStorageWidth(type.getElementType());
   size_t rawBufferWidth = rawBuffer.size() * CHAR_BIT;
   int64_t numElements = type.getNumElements();
 
   // The initializer is always a splat if the result type has a single element.
   detectedSplat = numElements == 1;
static bool isValidIntOrFloat(Type type, int64_t dataEltSize, bool isInt,
 
   // Make sure signedness semantics is consistent.
   if (intType.isSignless())
     return true;
   return intType.isSigned() ? isSigned : !isSigned;
 }
 
 /// Defaults down the subclass implementation.
-DenseElementsAttr DenseElementsAttr::getRawComplex(ShapedType type,
+DenseElementsAttr DenseElementsAttr::getRawComplex(RankedShapedType type,
                                                    ArrayRef<char> data,
                                                    int64_t dataEltSize,
                                                    bool isInt, bool isSigned) {
   return DenseIntOrFPElementsAttr::getRawComplex(type, data, dataEltSize, isInt,
                                                  isSigned);
 }
-DenseElementsAttr DenseElementsAttr::getRawIntOrFloat(ShapedType type,
+DenseElementsAttr DenseElementsAttr::getRawIntOrFloat(RankedShapedType type,
                                                       ArrayRef<char> data,
                                                       int64_t dataEltSize,
                                                       bool isInt,
                                                       bool isSigned) {
   return DenseIntOrFPElementsAttr::getRawIntOrFloat(type, data, dataEltSize,
                                                     isInt, isSigned);
 }
 

 
 ArrayRef<StringRef> DenseElementsAttr::getRawStringData() const {
   return static_cast<DenseStringElementsAttrStorage *>(impl)->data;
 }
 
 /// Return a new DenseElementsAttr that has the same data as the current
 /// attribute, but has been reshaped to 'newType'. The new type must have the
 /// same total number of elements as well as element type.
-DenseElementsAttr DenseElementsAttr::reshape(ShapedType newType) {
-  ShapedType curType = getType();
+DenseElementsAttr DenseElementsAttr::reshape(RankedShapedType newType) {
+  RankedShapedType curType = getType();
   if (curType == newType)
     return *this;
 
   assert(newType.getElementType() == curType.getElementType() &&
          "expected the same element type");
   assert(newType.getNumElements() == curType.getNumElements() &&
          "expected the same number of elements");
   return DenseIntOrFPElementsAttr::getRaw(newType, getRawData());
 }
 
-DenseElementsAttr DenseElementsAttr::resizeSplat(ShapedType newType) {
+DenseElementsAttr DenseElementsAttr::resizeSplat(RankedShapedType newType) {
   assert(isSplat() && "expected a splat type");
 
-  ShapedType curType = getType();
+  RankedShapedType curType = getType();
   if (curType == newType)
     return *this;
 
   assert(newType.getElementType() == curType.getElementType() &&
          "expected the same element type");
   return DenseIntOrFPElementsAttr::getRaw(newType, getRawData());
 }
 
 /// Return a new DenseElementsAttr that has the same data as the current
 /// attribute, but has bitcast elements such that it is now 'newType'. The new
 /// type must have the same shape and element types of the same bitwidth as the
 /// current type.
 DenseElementsAttr DenseElementsAttr::bitcast(Type newElType) {
-  ShapedType curType = getType();
+  RankedShapedType curType = getType();
   Type curElType = curType.getElementType();
   if (curElType == newElType)
     return *this;
 
   assert(getDenseElementBitWidth(newElType) ==
              getDenseElementBitWidth(curElType) &&
          "expected element types with the same bitwidth");
   return DenseIntOrFPElementsAttr::getRaw(curType.clone(newElType),
                                           getRawData());
 }
 
 DenseElementsAttr
 DenseElementsAttr::mapValues(Type newElementType,
                              function_ref<APInt(const APInt &)> mapping) const {
   return cast<DenseIntElementsAttr>().mapValues(newElementType, mapping);
 }
 
 DenseElementsAttr DenseElementsAttr::mapValues(
     Type newElementType, function_ref<APInt(const APFloat &)> mapping) const {
   return cast<DenseFPElementsAttr>().mapValues(newElementType, mapping);
 }
 
-ShapedType DenseElementsAttr::getType() const {
+RankedShapedType DenseElementsAttr::getType() const {
   return static_cast<const DenseElementsAttributeStorage *>(impl)->type;
 }
 
 Type DenseElementsAttr::getElementType() const {
   return getType().getElementType();
 }
 
 int64_t DenseElementsAttr::getNumElements() const {
static void writeAPIntsToBuffer(size_t storageWidth, std::vector<char> &data,
   // Handle the special encoding of splat of a boolean.
   if (numValues == 1 && (*values.begin()).getBitWidth() == 1)
     data[0] = data[0] ? -1 : 0;
 }
 
 /// Constructs a dense elements attribute from an array of raw APFloat values.
 /// Each APFloat value is expected to have the same bitwidth as the element
 /// type of 'type'. 'type' must be a vector or tensor with static shape.
-DenseElementsAttr DenseIntOrFPElementsAttr::getRaw(ShapedType type,
+DenseElementsAttr DenseIntOrFPElementsAttr::getRaw(RankedShapedType type,
                                                    size_t storageWidth,
                                                    ArrayRef<APFloat> values) {
   std::vector<char> data;
   auto unwrapFloat = [](const APFloat &val) { return val.bitcastToAPInt(); };
   writeAPIntsToBuffer(storageWidth, data, llvm::map_range(values, unwrapFloat));
   return DenseIntOrFPElementsAttr::getRaw(type, data);
 }
 
 /// Constructs a dense elements attribute from an array of raw APInt values.
 /// Each APInt value is expected to have the same bitwidth as the element type
 /// of 'type'.
-DenseElementsAttr DenseIntOrFPElementsAttr::getRaw(ShapedType type,
+DenseElementsAttr DenseIntOrFPElementsAttr::getRaw(RankedShapedType type,
                                                    size_t storageWidth,
                                                    ArrayRef<APInt> values) {
   std::vector<char> data;
   writeAPIntsToBuffer(storageWidth, data, values);
   return DenseIntOrFPElementsAttr::getRaw(type, data);
 }
 
-DenseElementsAttr DenseIntOrFPElementsAttr::getRaw(ShapedType type,
+DenseElementsAttr DenseIntOrFPElementsAttr::getRaw(RankedShapedType type,
                                                    ArrayRef<char> data) {
   assert(type.hasStaticShape() && "type must have static shape");
   bool isSplat = false;
   bool isValid = isValidRawBuffer(type, data, isSplat);
   assert(isValid);
   (void)isValid;
   return Base::get(type.getContext(), type, data, isSplat);
 }
 
 /// Overload of the raw 'get' method that asserts that the given type is of
 /// complex type. This method is used to verify type invariants that the
 /// templatized 'get' method cannot.
-DenseElementsAttr DenseIntOrFPElementsAttr::getRawComplex(ShapedType type,
+DenseElementsAttr DenseIntOrFPElementsAttr::getRawComplex(RankedShapedType type,
                                                           ArrayRef<char> data,
                                                           int64_t dataEltSize,
                                                           bool isInt,
                                                           bool isSigned) {
   assert(::isValidIntOrFloat(
       type.getElementType().cast<ComplexType>().getElementType(),
       dataEltSize / 2, isInt, isSigned));
 
   int64_t numElements = data.size() / dataEltSize;
   (void)numElements;
   assert(numElements == 1 || numElements == type.getNumElements());
   return getRaw(type, data);
 }
 
 /// Overload of the 'getRaw' method that asserts that the given type is of
 /// integer type. This method is used to verify type invariants that the
 /// templatized 'get' method cannot.
-DenseElementsAttr
-DenseIntOrFPElementsAttr::getRawIntOrFloat(ShapedType type, ArrayRef<char> data,
-                                           int64_t dataEltSize, bool isInt,
-                                           bool isSigned) {
+DenseElementsAttr DenseIntOrFPElementsAttr::getRawIntOrFloat(
+    RankedShapedType type, ArrayRef<char> data, int64_t dataEltSize, bool isInt,
   assert(
       ::isValidIntOrFloat(type.getElementType(), dataEltSize, isInt, isSigned));
 
   int64_t numElements = data.size() / dataEltSize;
   assert(numElements == 1 || numElements == type.getNumElements());
   (void)numElements;
   return getRaw(type, data);
 }
for (size_t i = 0; i < nBytes; i++)
       std::copy_n(inRawData + (nBytes - 1 - i), 1, outRawData + i);
     break;
   }
   }
 }
 
 void DenseIntOrFPElementsAttr::convertEndianOfArrayRefForBEmachine(
     ArrayRef<char> inRawData, MutableArrayRef<char> outRawData,
-    ShapedType type) {
+    RankedShapedType type) {
   size_t numElements = type.getNumElements();
   Type elementType = type.getElementType();
   if (ComplexType complexTy = elementType.dyn_cast<ComplexType>()) {
     elementType = complexTy.getElementType();
     numElements = numElements * 2;
   }
   size_t elementBitWidth = getDenseElementStorageWidth(elementType);
   assert(numElements * elementBitWidth == inRawData.size() * CHAR_BIT &&
          inRawData.size() <= outRawData.size());
   if (elementBitWidth <= CHAR_BIT)
     std::memcpy(outRawData.begin(), inRawData.begin(), inRawData.size());
   else
     convertEndianOfCharForBEmachine(inRawData.begin(), outRawData.begin(),
                                     elementBitWidth, numElements);
 }
 
 //===----------------------------------------------------------------------===//
 // DenseFPElementsAttr
 //===----------------------------------------------------------------------===//
 
 template <typename Fn, typename Attr>
-static ShapedType mappingHelper(Fn mapping, Attr &attr, ShapedType inType,
-                                Type newElementType,
-                                llvm::SmallVectorImpl<char> &data) {
+static RankedShapedType
+mappingHelper(Fn mapping, Attr &attr, RankedShapedType inType,
+              Type newElementType, llvm::SmallVectorImpl<char> &data) {
   size_t bitWidth = getDenseElementBitWidth(newElementType);
   size_t storageBitWidth = getDenseElementStorageWidth(bitWidth);
 
-  ShapedType newArrayType = inType.cloneWith(inType.getShape(), newElementType);
+  RankedShapedType newArrayType = cast<RankedShapedType>(
+      inType.cloneWith(inType.getShape(), newElementType));
 
   size_t numRawElements = attr.isSplat() ? 1 : newArrayType.getNumElements();
   data.resize(llvm::divideCeil(storageBitWidth * numRawElements, CHAR_BIT));
 
   // Functor used to process a single element value of the attribute.
   auto processElt = [&](decltype(*attr.begin()) value, size_t index) {
     auto newInt = mapping(value);
     assert(newInt.getBitWidth() == bitWidth);
bool DenseIntElementsAttr::classof(Attribute attr) {
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // DenseResourceElementsAttr
 //===----------------------------------------------------------------------===//
 
 DenseResourceElementsAttr
-DenseResourceElementsAttr::get(ShapedType type,
+DenseResourceElementsAttr::get(RankedShapedType type,
                                DenseResourceElementsHandle handle) {
   return Base::get(type.getContext(), type, handle);
 }
 
-DenseResourceElementsAttr DenseResourceElementsAttr::get(ShapedType type,
+DenseResourceElementsAttr DenseResourceElementsAttr::get(RankedShapedType type,
                                                          StringRef blobName,
                                                          AsmResourceBlob blob) {
   // Extract the builtin dialect resource manager from context and construct a
   // handle by inserting a new resource using the provided blob.
   auto &manager =
       DenseResourceElementsHandle::getManagerInterface(type.getContext());
   return get(type, manager.insert(blobName, std::move(blob)));
 }

 template <>
 struct DenseResourceAttrUtil<double> {
   static bool checkElementType(Type eltType) { return eltType.isF64(); }
 };
 } // namespace
 
 template <typename T>
 DenseResourceElementsAttrBase<T>
-DenseResourceElementsAttrBase<T>::get(ShapedType type, StringRef blobName,
+DenseResourceElementsAttrBase<T>::get(RankedShapedType type, StringRef blobName,
                                       AsmResourceBlob blob) {
   // Check that the blob is in the form we were expecting.
   assert(blob.getDataAlignment() == alignof(T) &&
          "alignment mismatch between expected alignment and blob alignment");
   assert(((blob.getData().size() % sizeof(T)) == 0) &&
          "size mismatch between expected element width and blob size");
   assert(DenseResourceAttrUtil<T>::checkElementType(type.getElementType()) &&
          "invalid shape element type for provided type `T`");
std::vector<ptrdiff_t> SparseElementsAttr::getFlattenedSparseIndices() const {
   auto numSparseIndices = sparseIndices.getType().getDimSize(0);
   size_t rank = getType().getRank();
   for (size_t i = 0, e = numSparseIndices; i != e; ++i)
     flatSparseIndices.push_back(getFlattenedIndex(
         {&*std::next(sparseIndexValues.begin(), i * rank), rank}));
   return flatSparseIndices;
 }
 
-LogicalResult
-SparseElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError,
-                           ShapedType type, DenseIntElementsAttr sparseIndices,
-                           DenseElementsAttr values) {
-  ShapedType valuesType = values.getType();
+LogicalResult SparseElementsAttr::verify(
+    function_ref<InFlightDiagnostic()> emitError, RankedShapedType type,
+    DenseIntElementsAttr sparseIndices, DenseElementsAttr values) {
+  RankedShapedType valuesType = values.getType();
   if (valuesType.getRank() != 1)
     return emitError() << "expected 1-d tensor for sparse element values";
 
   // Verify the indices and values shape.
-  ShapedType indicesType = sparseIndices.getType();
+  RankedShapedType indicesType = sparseIndices.getType();
   auto emitShapeError = [&]() {
     return emitError() << "expected shape ([" << type.getShape()
                        << "]); inferred shape of indices literal (["
                        << indicesType.getShape()
                        << "]); inferred shape of values literal (["
                        << valuesType.getShape() << "])";
   };
   // Verify indices shape.

 AffineMap mlir::makeStridedLinearLayoutMap(ArrayRef<int64_t> strides,
                                            int64_t offset,
                                            MLIRContext *context) {
   AffineExpr expr;
   unsigned nSymbols = 0;
 
   // AffineExpr for offset.
   // Static case.
-  if (!ShapedType::isDynamic(offset)) {
+  if (!RankedShapedType::isDynamic(offset)) {
     auto cst = getAffineConstantExpr(offset, context);
     expr = cst;
   } else {
     // Dynamic case, new symbol for the offset.
     auto sym = getAffineSymbolExpr(nSymbols++, context);
     expr = sym;
   }
 
   // AffineExpr for strides.
   for (const auto &en : llvm::enumerate(strides)) {
     auto dim = en.index();
     auto stride = en.value();
     assert(stride != 0 && "Invalid stride specification");
     auto d = getAffineDimExpr(dim, context);
     AffineExpr mult;
     // Static case.
-    if (!ShapedType::isDynamic(stride))
+    if (!RankedShapedType::isDynamic(stride))
       mult = getAffineConstantExpr(stride, context);
     else
       // Dynamic case, new symbol for each new stride.
       mult = getAffineSymbolExpr(nSymbols++, context);
     expr = expr + d * mult;
   }
 
   return AffineMap::get(strides.size(), nSymbols, expr);
 }

mlir/lib/IR/BuiltinDialectBytecode.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // DenseStringElementsAttr
 
 DenseStringElementsAttr
 BuiltinDialectBytecodeInterface::readDenseStringElementsAttr(
     DialectBytecodeReader &reader) const {
-  ShapedType type;
+  RankedShapedType type;
   uint64_t isSplat;
   if (failed(reader.readType(type)) || failed(reader.readVarInt(isSplat)))
     return DenseStringElementsAttr();
 
   SmallVector<StringRef> values(isSplat ? 1 : type.getNumElements());
   for (StringRef &value : values)
     if (failed(reader.readString(value)))
       return DenseStringElementsAttr();

mlir/lib/IR/BuiltinTypeInterfaces.cpp

 
 //===----------------------------------------------------------------------===//
 /// Tablegen Interface Definitions
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/BuiltinTypeInterfaces.cpp.inc"
 
 //===----------------------------------------------------------------------===//
-// ShapedType
+// RankedShapedType
 //===----------------------------------------------------------------------===//
 
-constexpr int64_t ShapedType::kDynamic;
+constexpr int64_t RankedShapedType::kDynamic;
 
-int64_t ShapedType::getNumElements(ArrayRef<int64_t> shape) {
+int64_t RankedShapedType::getNumElements(ArrayRef<int64_t> shape) {
   int64_t num = 1;
   for (int64_t dim : shape) {
+    assert(!RankedShapedType::isDynamic(dim) && "expected only static dims");
     num *= dim;
     assert(num >= 0 && "integer overflow in element count computation");
   }
   return num;
 }

mlir/lib/IR/BuiltinTypes.cpp

 Type TensorType::getElementType() const {
   return llvm::TypeSwitch<TensorType, Type>(*this)
       .Case<RankedTensorType, UnrankedTensorType>(
           [](auto type) { return type.getElementType(); });
 }
 
 bool TensorType::hasRank() const { return !isa<UnrankedTensorType>(); }
 
-ArrayRef<int64_t> TensorType::getShape() const {
-  return cast<RankedTensorType>().getShape();
-}
-
 TensorType TensorType::cloneWith(std::optional<ArrayRef<int64_t>> shape,
                                  Type elementType) const {
   if (auto unrankedTy = dyn_cast<UnrankedTensorType>()) {
     if (shape)
       return RankedTensorType::get(*shape, elementType);
     return UnrankedTensorType::get(elementType);
   }
 

 // RankedTensorType
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 RankedTensorType::verify(function_ref<InFlightDiagnostic()> emitError,
                          ArrayRef<int64_t> shape, Type elementType,
                          Attribute encoding) {
   for (int64_t s : shape)
-    if (s < 0 && !ShapedType::isDynamic(s))
+    if (s < 0 && !RankedShapedType::isDynamic(s))
       return emitError() << "invalid tensor dimension size";
   if (auto v = encoding.dyn_cast_or_null<VerifiableTensorEncoding>())
     if (failed(v.verifyEncoding(shape, elementType, emitError)))
       return failure();
   return checkTensorElementType(emitError, elementType);
 }
 
 //===----------------------------------------------------------------------===//

 Type BaseMemRefType::getElementType() const {
   return llvm::TypeSwitch<BaseMemRefType, Type>(*this)
       .Case<MemRefType, UnrankedMemRefType>(
           [](auto type) { return type.getElementType(); });
 }
 
 bool BaseMemRefType::hasRank() const { return !isa<UnrankedMemRefType>(); }
 
-ArrayRef<int64_t> BaseMemRefType::getShape() const {
-  return cast<MemRefType>().getShape();
-}
-
 BaseMemRefType BaseMemRefType::cloneWith(std::optional<ArrayRef<int64_t>> shape,
                                          Type elementType) const {
   if (auto unrankedTy = dyn_cast<UnrankedMemRefType>()) {
     if (!shape)
       return UnrankedMemRefType::get(elementType, getMemorySpace());
     MemRefType::Builder builder(*shape, elementType);
     builder.setMemorySpace(getMemorySpace());
     return builder;

 }
 
 SliceVerificationResult
 mlir::isRankReducedType(ShapedType originalType,
                         ShapedType candidateReducedType) {
   if (originalType == candidateReducedType)
     return SliceVerificationResult::Success;
 
-  ShapedType originalShapedType = originalType.cast<ShapedType>();
-  ShapedType candidateReducedShapedType =
-      candidateReducedType.cast<ShapedType>();
+  auto originalShapedType = originalType.cast<RankedShapedType>();
+  auto candidateReducedShapedType =
+      candidateReducedType.cast<RankedShapedType>();
 
   // Rank and size logic is valid for all ShapedTypes.
   ArrayRef<int64_t> originalShape = originalShapedType.getShape();
   ArrayRef<int64_t> candidateReducedShape =
       candidateReducedShapedType.getShape();
   unsigned originalRank = originalShape.size(),
            candidateReducedRank = candidateReducedShape.size();
   if (candidateReducedRank > originalRank)
LogicalResult MemRefType::verify(function_ref<InFlightDiagnostic()> emitError,
                                  ArrayRef<int64_t> shape, Type elementType,
                                  MemRefLayoutAttrInterface layout,
                                  Attribute memorySpace) {
   if (!BaseMemRefType::isValidElementType(elementType))
     return emitError() << "invalid memref element type";
 
   // Negative sizes are not allowed except for `kDynamic`.
   for (int64_t s : shape)
-    if (s < 0 && !ShapedType::isDynamic(s))
+    if (s < 0 && !RankedShapedType::isDynamic(s))
       return emitError() << "invalid memref size";
 
   assert(layout && "missing layout specification");
   if (failed(layout.verifyLayout(shape, emitError)))
     return failure();
 
   if (!isSupportedMemorySpace(memorySpace))
     return emitError() << "unsupported memory space Attribute";
LogicalResult mlir::getStridesAndOffset(MemRefType t,
   // convertible to affine maps.
   AffineExpr offsetExpr;
   SmallVector<AffineExpr, 4> strideExprs;
   if (failed(::getStridesAndOffset(t, strideExprs, offsetExpr)))
     return failure();
   if (auto cst = offsetExpr.dyn_cast<AffineConstantExpr>())
     offset = cst.getValue();
   else
-    offset = ShapedType::kDynamic;
+    offset = RankedShapedType::kDynamic;
   for (auto e : strideExprs) {
     if (auto c = e.dyn_cast<AffineConstantExpr>())
       strides.push_back(c.getValue());
     else
-      strides.push_back(ShapedType::kDynamic);
+      strides.push_back(RankedShapedType::kDynamic);
   }
   return success();
 }
 
 std::pair<SmallVector<int64_t>, int64_t>
 mlir::getStridesAndOffset(MemRefType t) {
   SmallVector<int64_t> strides;
   int64_t offset;

mlir/lib/IR/TypeUtilities.cpp

 /// dynamic.
 LogicalResult mlir::verifyCompatibleShape(ArrayRef<int64_t> shape1,
                                           ArrayRef<int64_t> shape2) {
   if (shape1.size() != shape2.size())
     return failure();
   for (auto dims : llvm::zip(shape1, shape2)) {
     int64_t dim1 = std::get<0>(dims);
     int64_t dim2 = std::get<1>(dims);
-    if (!ShapedType::isDynamic(dim1) && !ShapedType::isDynamic(dim2) &&
-        dim1 != dim2)
+    if (!RankedShapedType::isDynamic(dim1) &&
+        !RankedShapedType::isDynamic(dim2) && dim1 != dim2)
       return failure();
   }
   return success();
 }
 
 /// Returns success if the given two types have compatible shape. That is,
 /// they are both scalars (not shaped), or they are both shaped types and at
 /// least one is unranked or they have compatible dimensions. Dimensions are
 /// compatible if at least one is dynamic or both are equal. The element type
 /// does not matter.
 LogicalResult mlir::verifyCompatibleShape(Type type1, Type type2) {
   auto sType1 = type1.dyn_cast<ShapedType>();
   auto sType2 = type2.dyn_cast<ShapedType>();
 
   // Either both or neither type should be shaped.
   if (!sType1)
     return success(!sType2);
   if (!sType2)
     return failure();
 
-  if (!sType1.hasRank() || !sType2.hasRank())
+  if (!isa<RankedShapedType>(sType1) || !isa<RankedShapedType>(sType2))
     return success();
 
-  return verifyCompatibleShape(sType1.getShape(), sType2.getShape());
+  return verifyCompatibleShape(cast<RankedShapedType>(sType1).getShape(),
+                               cast<RankedShapedType>(sType2).getShape());
 }
 
 /// Returns success if the given two arrays have the same number of elements and
 /// each pair wise entries have compatible shape.
 LogicalResult mlir::verifyCompatibleShapes(TypeRange types1, TypeRange types2) {
   if (types1.size() != types2.size())
     return failure();
   for (auto it : llvm::zip_first(types1, types2))
     if (failed(verifyCompatibleShape(std::get<0>(it), std::get<1>(it))))
       return failure();
   return success();
 }
 
 LogicalResult mlir::verifyCompatibleDims(ArrayRef<int64_t> dims) {
   if (dims.empty())
     return success();
   auto staticDim = std::accumulate(
       dims.begin(), dims.end(), dims.front(), [](auto fold, auto dim) {
-        return ShapedType::isDynamic(dim) ? fold : dim;
+        return RankedShapedType::isDynamic(dim) ? fold : dim;
       });
   return success(llvm::all_of(dims, [&](auto dim) {
-    return ShapedType::isDynamic(dim) || dim == staticDim;
+    return RankedShapedType::isDynamic(dim) || dim == staticDim;
   }));
 }
 
 /// Returns success if all given types have compatible shapes. That is, they are
 /// all scalars (not shaped), or they are all shaped types and any ranked shapes
 /// have compatible dimensions. Dimensions are compatible if all non-dynamic
 /// dims are equal. The element type does not matter.
 LogicalResult mlir::verifyCompatibleShapes(TypeRange types) {
if (vType && vType.isScalable())
       hasScalableVecTypes = true;
     else
       hasNonScalableVecTypes = true;
     if (hasScalableVecTypes && hasNonScalableVecTypes)
       return failure();
   }
 
   // Remove all unranked shapes
-  auto shapes = llvm::to_vector<8>(llvm::make_filter_range(
-      shapedTypes, [](auto shapedType) { return shapedType.hasRank(); }));
+  auto shapes = llvm::to_vector<8>(
+      llvm::make_filter_range(shapedTypes, [](auto shapedType) {
+        return isa<RankedShapedType>(shapedType);
+      }));
   if (shapes.empty())
     return success();
 
   // All ranks should be equal
-  auto firstRank = shapes.front().getRank();
-  if (llvm::any_of(shapes,
-                   [&](auto shape) { return firstRank != shape.getRank(); }))
+  auto firstRank = cast<RankedShapedType>(shapes.front()).getRank();
+  if (llvm::any_of(shapes, [&](auto shape) {
+        return firstRank != cast<RankedShapedType>(shape).getRank();
+      }))
     return failure();
 
   for (unsigned i = 0; i < firstRank; ++i) {
     // Retrieve all ranked dimensions
     auto dims = llvm::to_vector<8>(llvm::map_range(
         llvm::make_filter_range(
-            shapes, [&](auto shape) { return shape.getRank() >= i; }),
-        [&](auto shape) { return shape.getDimSize(i); }));
+            shapes,
+            [&](auto shape) {
+              return cast<RankedShapedType>(shape).getRank() >= i;
+            }),
+        [&](auto shape) {
+          return cast<RankedShapedType>(shape).getDimSize(i);
+        }));
     if (verifyCompatibleDims(dims).failed())
       return failure();
   }
 
   return success();
 }
 
 Type OperandElementTypeIterator::mapElement(Value value) const {
   return value.getType().cast<ShapedType>().getElementType();
 }
 
 Type ResultElementTypeIterator::mapElement(Value value) const {
   return value.getType().cast<ShapedType>().getElementType();
 }

mlir/lib/Interfaces/InferTypeOpInterface.cpp

if (failed(status))
     return failure();
   // Assert that ReifyRankedShapedTypeOpInterface::reifyResultShapes produced
   // a correct result.
   int64_t resultIdx = 0;
   for (OpResult result : op->getResults()) {
     auto shapedType = result.getType().dyn_cast<ShapedType>();
     if (!shapedType)
       continue;
-    if (!shapedType.hasRank()) {
+    if (!isa<RankedShapedType>(shapedType)) {
       // Nothing to check for unranked shaped values.
       ++resultIdx;
       continue;
     }
+    auto rankedShapedType = cast<RankedShapedType>(shapedType);
     // Assert one OpFoldResult per dimension.
-    assert(shapedType.getRank() ==
+    assert(rankedShapedType.getRank() ==
                static_cast<int64_t>(reifiedReturnShapes[resultIdx].size()) &&
            "incorrect implementation of ReifyRankedShapedTypeOpInterface");
-    for (int64_t dim = 0; dim < shapedType.getRank(); ++dim) {
+    for (int64_t dim = 0; dim < rankedShapedType.getRank(); ++dim) {
       // reifyResultShapes must return:
       // * Attribute for static dimensions
       // * Value for dynamic dimensions
-      assert(shapedType.isDynamicDim(dim) ==
+      assert(rankedShapedType.isDynamicDim(dim) ==
                  reifiedReturnShapes[resultIdx][dim].is<Value>() &&
              "incorrect implementation of ReifyRankedShapedTypeOpInterface");
     }
     ++resultIdx;
   }
   // Assert that every shaped value result was reified.
   assert(resultIdx == static_cast<int64_t>(reifiedReturnShapes.size()) &&
          "incorrect implementation of ReifyRankedShapedTypeOpInterface");
 #endif // NDEBUG
   return status;
 }
 
 bool ShapeAdaptor::hasRank() const {
   if (val.isNull())
     return false;
   if (auto t = val.dyn_cast<Type>())
-    return t.cast<ShapedType>().hasRank();
+    return isa<RankedShapedType>(t);
   if (val.is<Attribute>())
     return true;
   return val.get<ShapedTypeComponents *>()->hasRank();
 }
 
 Type ShapeAdaptor::getElementType() const {
   if (val.isNull())
     return nullptr;
   if (auto t = val.dyn_cast<Type>())
     return t.cast<ShapedType>().getElementType();
   if (val.is<Attribute>())
     return nullptr;
   return val.get<ShapedTypeComponents *>()->getElementType();
 }
 
 void ShapeAdaptor::getDims(SmallVectorImpl<int64_t> &res) const {
   assert(hasRank());
   if (auto t = val.dyn_cast<Type>()) {
-    ArrayRef<int64_t> vals = t.cast<ShapedType>().getShape();
+    ArrayRef<int64_t> vals = t.cast<RankedShapedType>().getShape();
     res.assign(vals.begin(), vals.end());
   } else if (auto attr = val.dyn_cast<Attribute>()) {
     auto dattr = attr.cast<DenseIntElementsAttr>();
     res.clear();
     res.reserve(dattr.size());
     for (auto it : dattr.getValues<APInt>())
       res.push_back(it.getSExtValue());
   } else {
     auto vals = val.get<ShapedTypeComponents *>()->getDims();
     res.assign(vals.begin(), vals.end());
   }
 }
 
 void ShapeAdaptor::getDims(ShapedTypeComponents &res) const {
   assert(hasRank());
   res.ranked = true;
   getDims(res.dims);
 }
 
 int64_t ShapeAdaptor::getDimSize(int index) const {
   assert(hasRank());
   if (auto t = val.dyn_cast<Type>())
-    return t.cast<ShapedType>().getDimSize(index);
+    return t.cast<RankedShapedType>().getDimSize(index);
   if (auto attr = val.dyn_cast<Attribute>())
     return attr.cast<DenseIntElementsAttr>()
         .getValues<APInt>()[index]
         .getSExtValue();
   auto *stc = val.get<ShapedTypeComponents *>();
   return stc->getDims()[index];
 }
 
 int64_t ShapeAdaptor::getRank() const {
   assert(hasRank());
   if (auto t = val.dyn_cast<Type>())
-    return t.cast<ShapedType>().getRank();
+    return t.cast<RankedShapedType>().getRank();
   if (auto attr = val.dyn_cast<Attribute>())
     return attr.cast<DenseIntElementsAttr>().size();
   return val.get<ShapedTypeComponents *>()->getDims().size();
 }
 
 bool ShapeAdaptor::hasStaticShape() const {
   if (!hasRank())
     return false;
 
   if (auto t = val.dyn_cast<Type>())
-    return t.cast<ShapedType>().hasStaticShape();
+    return t.cast<RankedShapedType>().hasStaticShape();
   if (auto attr = val.dyn_cast<Attribute>()) {
     auto dattr = attr.cast<DenseIntElementsAttr>();
     for (auto index : dattr.getValues<APInt>())
-      if (ShapedType::isDynamic(index.getSExtValue()))
+      if (RankedShapedType::isDynamic(index.getSExtValue()))
         return false;
     return true;
   }
   auto *stc = val.get<ShapedTypeComponents *>();
-  return llvm::none_of(stc->getDims(), ShapedType::isDynamic);
+  return llvm::none_of(stc->getDims(), RankedShapedType::isDynamic);
 }
 
 int64_t ShapeAdaptor::getNumElements() const {
   assert(hasStaticShape() && "cannot get element count of dynamic shaped type");
 
   if (auto t = val.dyn_cast<Type>())
-    return t.cast<ShapedType>().getNumElements();
+    return t.cast<RankedShapedType>().getNumElements();
 
   if (auto attr = val.dyn_cast<Attribute>()) {
     auto dattr = attr.cast<DenseIntElementsAttr>();
     int64_t num = 1;
     for (auto index : dattr.getValues<APInt>()) {
       num *= index.getZExtValue();
       assert(num >= 0 && "integer overflow in element count computation");
     }
void ShapeAdaptor::dump() const {
   if (!hasRank()) {
     llvm::errs() << "<<unranked>>\n";
     return;
   }
 
   SmallVector<int64_t> dims;
   getDims(dims);
   auto mapped = llvm::map_range(dims, [](int64_t dim) -> std::string {
-    if (ShapedType::isDynamic(dim))
+    if (RankedShapedType::isDynamic(dim))
       return "?";
     return llvm::formatv("{0}", dim).str();
   });
   llvm::errs() << "rank = " << getRank() << " dims = [";
   llvm::interleave(mapped, llvm::errs(), "x");
   llvm::errs() << "]\n";
 }
 

mlir/lib/Interfaces/ValueBoundsOpInterface.cpp

 }
 
 #ifndef NDEBUG
 static void assertValidValueDim(Value value, std::optional<int64_t> dim) {
   if (value.getType().isIndex()) {
     assert(!dim.has_value() && "invalid dim value");
   } else if (auto shapedType = dyn_cast<ShapedType>(value.getType())) {
     assert(*dim >= 0 && "invalid dim value");
-    if (shapedType.hasRank())
-      assert(*dim < shapedType.getRank() && "invalid dim value");
+    if (auto rankedShapedType = dyn_cast<RankedShapedType>(shapedType))
+      assert(*dim < rankedShapedType.getRank() && "invalid dim value");
   } else {
     llvm_unreachable("unsupported type");
   }
 }
 #endif // NDEBUG
 
 void ValueBoundsConstraintSet::addBound(BoundType type, int64_t pos,
                                         AffineExpr expr) {
AffineExpr ValueBoundsConstraintSet::getExpr(Value value,
                                              std::optional<int64_t> dim) {
 #ifndef NDEBUG
   assertValidValueDim(value, dim);
 #endif // NDEBUG
 
   auto shapedType = dyn_cast<ShapedType>(value.getType());
   if (shapedType) {
     // Static dimension: return constant directly.
-    if (shapedType.hasRank() && !shapedType.isDynamicDim(*dim))
-      return builder.getAffineConstantExpr(shapedType.getDimSize(*dim));
+    auto rankedShapedType = dyn_cast<RankedShapedType>(shapedType);
+    if (rankedShapedType && !rankedShapedType.isDynamicDim(*dim))
+      return builder.getAffineConstantExpr(rankedShapedType.getDimSize(*dim));
   } else {
     // Constant index value: return directly.
     if (auto constInt = getConstantIntValue(value))
       return builder.getAffineConstantExpr(*constInt);
   }
 
   // Dynamic value: add to constraint set.
   ValueDim valueDim = std::make_pair(value, dim.value_or(kIndexValue));
while (!worklist.empty()) {
     int64_t pos = worklist.front();
     worklist.pop();
     ValueDim valueDim = positionToValueDim[pos];
     Value value = valueDim.first;
     int64_t dim = valueDim.second;
 
     // Check for static dim size.
     if (dim != kIndexValue) {
-      auto shapedType = cast<ShapedType>(value.getType());
-      if (shapedType.hasRank() && !shapedType.isDynamicDim(dim)) {
-        bound(value)[dim] == getExpr(shapedType.getDimSize(dim));
+      auto rankedShapedType = cast<RankedShapedType>(value.getType());
+      if (rankedShapedType && !rankedShapedType.isDynamicDim(dim)) {
+        bound(value)[dim] == getExpr(rankedShapedType.getDimSize(dim));
         continue;
       }
     }
 
     // Do not process any further if the stop condition is met.
     auto maybeDim = dim == kIndexValue ? std::nullopt : std::make_optional(dim);
     if (stopCondition(value, maybeDim))
       continue;
for (int64_t i = 0; i < cstr.cstr.getNumDimAndSymbolVars(); ++i) {
     if (dim == ValueBoundsConstraintSet::kIndexValue) {
       // An index-type value is used: can be used directly in the affine.apply
       // op.
       assert(value.getType().isIndex() && "expected index type");
       mapOperands.push_back(std::make_pair(value, std::nullopt));
       continue;
     }
 
-    assert(cast<ShapedType>(value.getType()).isDynamicDim(dim) &&
+    auto rankedShapedType = cast<RankedShapedType>(value.getType());
+    (void)rankedShapedType;
+    assert((!rankedShapedType || rankedShapedType.isDynamicDim(dim)) &&
            "expected dynamic dim");
     mapOperands.push_back(std::make_pair(value, dim));
   }
 
   resultMap = bound.replaceDimsAndSymbols(replacementDims, replacementSymbols,
                                           numDims, numSymbols);
   return success();
 }

mlir/lib/Interfaces/ViewLikeInterface.cpp

LogicalResult mlir::verifyListOfOperandsOrIntegers(Operation *op,
                                                    ArrayRef<int64_t> staticVals,
                                                    ValueRange values) {
   // Check static and dynamic offsets/sizes/strides does not overflow type.
   if (staticVals.size() != numElements)
     return op->emitError("expected ") << numElements << " " << name
                                       << " values, got " << staticVals.size();
   unsigned expectedNumDynamicEntries =
       llvm::count_if(staticVals, [&](int64_t staticVal) {
-        return ShapedType::isDynamic(staticVal);
+        return RankedShapedType::isDynamic(staticVal);
       });
   if (values.size() != expectedNumDynamicEntries)
     return op->emitError("expected ")
            << expectedNumDynamicEntries << " dynamic " << name << " values";
   return success();
 }
 
 LogicalResult
void mlir::printDynamicIndexList(OpAsmPrinter &printer, Operation *op,
   char rightDelimiter = getRightDelimiter(delimiter);
   printer << leftDelimiter;
   if (integers.empty()) {
     printer << rightDelimiter;
     return;
   }
   unsigned idx = 0;
   llvm::interleaveComma(integers, printer, [&](int64_t integer) {
-    if (ShapedType::isDynamic(integer))
+    if (RankedShapedType::isDynamic(integer))
       printer << values[idx++];
     else
       printer << integer;
   });
   printer << rightDelimiter;
 }
 
 ParseResult mlir::parseDynamicIndexList(
     OpAsmParser &parser,
     SmallVectorImpl<OpAsmParser::UnresolvedOperand> &values,
     DenseI64ArrayAttr &integers, AsmParser::Delimiter delimiter) {
 
   SmallVector<int64_t, 4> integerVals;
   auto parseIntegerOrValue = [&]() {
     OpAsmParser::UnresolvedOperand operand;
     auto res = parser.parseOptionalOperand(operand);
     if (res.has_value() && succeeded(res.value())) {
       values.push_back(operand);
-      integerVals.push_back(ShapedType::kDynamic);
+      integerVals.push_back(RankedShapedType::kDynamic);
     } else {
       int64_t integer;
       if (failed(parser.parseInteger(integer)))
         return failure();
       integerVals.push_back(integer);
     }
     return success();
   };

mlir/lib/Target/Cpp/TranslateToCpp.cpp

case 64:
       return (os << "double"), success();
     default:
       return emitError(loc, "cannot emit float type ") << type;
     }
   }
   if (auto iType = type.dyn_cast<IndexType>())
     return (os << "size_t"), success();
   if (auto tType = type.dyn_cast<TensorType>()) {
-    if (!tType.hasRank())
+    auto rtType = dyn_cast<RankedTensorType>(tType);
+    if (!rtType)
       return emitError(loc, "cannot emit unranked tensor type");
-    if (!tType.hasStaticShape())
+    if (!rtType.hasStaticShape())
       return emitError(loc, "cannot emit tensor type with non static shape");
     os << "Tensor<";
-    if (failed(emitType(loc, tType.getElementType())))
+    if (failed(emitType(loc, rtType.getElementType())))
       return failure();
-    auto shape = tType.getShape();
+    auto shape = rtType.getShape();
     for (auto dimSize : shape) {
       os << ", ";
       os << dimSize;
     }
     os << ">";
     return success();
   }
   if (auto tType = type.dyn_cast<TupleType>())

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

convertDenseElementsAttr(Location loc, DenseElementsAttr denseElementsAttr,
                          const ModuleTranslation &moduleTranslation) {
   if (!denseElementsAttr)
     return nullptr;
 
   llvm::Type *innermostLLVMType = getInnermostElementType(llvmType);
   if (!llvm::ConstantDataSequential::isElementTypeCompatible(innermostLLVMType))
     return nullptr;
 
-  ShapedType type = denseElementsAttr.getType();
+  RankedShapedType type = denseElementsAttr.getType();
   if (type.getNumElements() == 0)
     return nullptr;
 
   // Check that the raw data size matches what is expected for the scalar size.
   // TODO: in theory, we could repack the data here to keep constructing from
   // raw data.
   // TODO: we may also need to consider endianness when cross-compiling to an
   // architecture where it is different.

mlir/lib/Target/SPIRV/Serialization/Serializer.cpp

uint32_t Serializer::prepareConstant(Location loc, Type constType,
 
   uint32_t typeID = 0;
   if (failed(processType(loc, constType, typeID))) {
     return 0;
   }
 
   uint32_t resultID = 0;
   if (auto attr = valueAttr.dyn_cast<DenseElementsAttr>()) {
-    int rank = attr.getType().dyn_cast<ShapedType>().getRank();
+    int rank = attr.getType().dyn_cast<RankedShapedType>().getRank();
     SmallVector<uint64_t, 4> index(rank);
     resultID = prepareDenseElementsConstant(loc, constType, attr,
                                             /*dim=*/0, index);
   } else if (auto arrayAttr = valueAttr.dyn_cast<ArrayAttr>()) {
     resultID = prepareArrayConstant(loc, constType, arrayAttr);
   }
 
   if (resultID == 0) {

 }
 
 // TODO: Turn the below function into iterative function, instead of
 // recursive function.
 uint32_t
 Serializer::prepareDenseElementsConstant(Location loc, Type constType,
                                          DenseElementsAttr valueAttr, int dim,
                                          MutableArrayRef<uint64_t> index) {
-  auto shapedType = valueAttr.getType().dyn_cast<ShapedType>();
+  auto shapedType = valueAttr.getType().dyn_cast<RankedShapedType>();
   assert(dim <= shapedType.getRank());
   if (shapedType.getRank() == dim) {
     if (auto attr = valueAttr.dyn_cast<DenseIntElementsAttr>()) {
       return attr.getType().getElementType().isInteger(1)
                  ? prepareConstantBool(loc, attr.getValues<BoolAttr>()[index])
                  : prepareConstantInt(loc,
                                       attr.getValues<IntegerAttr>()[index]);
     }

mlir/test/lib/Analysis/TestMemRefStrideCalculation.cpp

getOperation().walk([&](memref::AllocOp allocOp) {
     int64_t offset;
     SmallVector<int64_t, 4> strides;
     if (failed(getStridesAndOffset(memrefType, strides, offset))) {
       llvm::outs() << "MemRefType " << memrefType << " cannot be converted to "
                    << "strided form\n";
       return;
     }
     llvm::outs() << "MemRefType offset: ";
-    if (ShapedType::isDynamic(offset))
+    if (RankedShapedType::isDynamic(offset))
       llvm::outs() << "?";
     else
       llvm::outs() << offset;
     llvm::outs() << " strides: ";
     llvm::interleaveComma(strides, llvm::outs(), [&](int64_t v) {
-      if (ShapedType::isDynamic(v))
+      if (RankedShapedType::isDynamic(v))
         llvm::outs() << "?";
       else
         llvm::outs() << v;
     });
     llvm::outs() << "\n";
   });
   llvm::outs().flush();
 }
 
 namespace mlir {
 namespace test {
 void registerTestMemRefStrideCalculation() {
   PassRegistration<TestMemRefStrideCalculation>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp

 
 static void applyFoldConstantExtractSlicePatterns(Operation *rootOp) {
   RewritePatternSet patterns(rootOp->getContext());
   tensor::ControlConstantExtractSliceFusionFn controlFn =
       [](tensor::ExtractSliceOp op) {
         if (!op.getSource().hasOneUse())
           return false;
 
-        auto resultType = op.getResult().getType().cast<ShapedType>();
+        auto resultType = op.getResult().getType().cast<RankedShapedType>();
         constexpr int64_t kConstantFoldingMaxNumElements = 1024;
         return resultType.getNumElements() <= kConstantFoldingMaxNumElements;
       };
 
   tensor::populateFoldConstantExtractSlicePatterns(patterns, controlFn);
   (void)applyPatternsAndFoldGreedily(rootOp, std::move(patterns));
 }
 

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

 }
 
 // Test support for ElementsAttrInterface.
 def TestI64ElementsAttr : Test_Attr<"TestI64Elements", [
     ElementsAttrInterface, TypedAttrInterface
   ]> {
   let mnemonic = "i64_elements";
   let parameters = (ins
-    AttributeSelfTypeParameter<"", "::mlir::ShapedType">:$type,
+    AttributeSelfTypeParameter<"", "::mlir::RankedShapedType">:$type,
     ArrayRefParameter<"uint64_t">:$elements
   );
   let extraClassDeclaration = [{
     /// The set of data types that can be iterated by this attribute.
     using ContiguousIterableTypesT = std::tuple<uint64_t>;
     using NonContiguousIterableTypesT = std::tuple<mlir::Attribute, llvm::APInt>;
 
     /// Provide begin iterators for the various iterable types.

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

 void TestI64ElementsAttr::print(AsmPrinter &printer) const {
   printer << "<[";
   llvm::interleaveComma(getElements(), printer);
   printer << "] : " << getType() << ">";
 }
 
 LogicalResult
 TestI64ElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError,
-                            ShapedType type, ArrayRef<uint64_t> elements) {
+                            RankedShapedType type,
+                            ArrayRef<uint64_t> elements) {
   if (type.getNumElements() != static_cast<int64_t>(elements.size())) {
     return emitError()
            << "number of elements does not match the provided shape type, got: "
            << elements.size() << ", but expected: " << type.getNumElements();
   }
   if (type.getRank() != 1 || !type.getElementType().isSignlessInteger(64))
     return emitError() << "expected single rank 64-bit shape type, but got: "
                        << type;

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

LogicalResult OpWithShapedTypeInferTypeInterfaceOp::inferReturnTypeComponents(
     ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   // Create return type consisting of the last element of the first operand.
   auto operandType = operands.front().getType();
   auto sval = operandType.dyn_cast<ShapedType>();
   if (!sval) {
     return emitOptionalError(location, "only shaped type operands allowed");
   }
-  int64_t dim = sval.hasRank() ? sval.getShape().front() : ShapedType::kDynamic;
+  auto rsval = sval.dyn_cast<RankedShapedType>();
+  int64_t dim = rsval ? rsval.getShape().front() : RankedShapedType::kDynamic;
   auto type = IntegerType::get(context, 17);
 
   Attribute encoding;
   if (auto rankedTy = sval.dyn_cast<RankedTensorType>())
     encoding = rankedTy.getEncoding();
   inferredReturnShapes.push_back(ShapedTypeComponents({dim}, type, encoding));
   return success();
 }

mlir/unittests/Dialect/BroadcastShapeTest.cpp

 TEST(BroadcastShapeTest, InterleavingOnes) {
   SmallVector<int64_t, 4> result;
   ASSERT_TRUE(getBroadcastedShape({8, 1, 2, 1, 4}, {5, 1, 7, 1}, result));
   EXPECT_THAT(result, ElementsAre(8, 5, 2, 7, 4));
 }
 
 TEST(BroadcastShapeTest, InterleavingUnknowns) {
   SmallVector<int64_t, 4> result;
-  int64_t dyn = mlir::ShapedType::kDynamic;
+  int64_t dyn = mlir::RankedShapedType::kDynamic;
   ASSERT_TRUE(getBroadcastedShape({1, 2, dyn, dyn, dyn}, {dyn, dyn, dyn, 4, 1},
                                   result));
   EXPECT_THAT(result, ElementsAre(dyn, 2, dyn, 4, dyn));
 }
 
 TEST(BroadcastShapeTest, IncompatibleLowDim) {
   SmallVector<int64_t, 4> result;
   ASSERT_FALSE(getBroadcastedShape({4, 3, 5, 5}, {3, 5, 4}, result));