Clean up usages of asserting vector getters in Type

[ctetreau]

Summary

Remove usages of asserting vector getters in Type in preparation for the
VectorType refactor. The existence of these functions complicates the
refactor while adding little value.

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

matchAndRewrite(Operation *op, ArrayRef<Value> operands,
     auto vectorType = resultType.dyn_cast<VectorType>();
     if (!vectorType)
       return failure();
 
     return handleMultidimensionalVectors(
         op, operands, typeConverter,
         [&](LLVM::LLVMType llvmVectorTy, ValueRange operands) {
           auto splatAttr = SplatElementsAttr::get(
-              mlir::VectorType::get(
-                  {llvmVectorTy.getUnderlyingType()->getVectorNumElements()},
+              mlir::VectorType::get({(unsigned)cast<llvm::VectorType>(
+                                         llvmVectorTy.getUnderlyingType())
+                                         ->getNumElements()},
                                     floatType),
               floatOne);
           auto one =
               rewriter.create<LLVM::ConstantOp>(loc, llvmVectorTy, splatAttr);
           auto sqrt =
               rewriter.create<LLVM::SqrtOp>(loc, llvmVectorTy, operands[0]);
           return rewriter.create<LLVM::FDivOp>(loc, llvmVectorTy, one, sqrt);
         },
         rewriter);

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

static ParseResult parseCmpOp(OpAsmParser &parser, OperationState &result) {
   // vectors.
   auto *dialect = builder.getContext()->getRegisteredDialect<LLVMDialect>();
   auto resultType = LLVMType::getInt1Ty(dialect);
   auto argType = type.dyn_cast<LLVM::LLVMType>();
   if (!argType)
     return parser.emitError(trailingTypeLoc, "expected LLVM IR dialect type");
   if (argType.getUnderlyingType()->isVectorTy())
     resultType = LLVMType::getVectorTy(
-        resultType, argType.getUnderlyingType()->getVectorNumElements());
+        resultType, llvm::cast<llvm::VectorType>(argType.getUnderlyingType())
+                        ->getNumElements());
 
   result.addTypes({resultType});
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Printing/parsing for LLVM::AllocaOp.
 //===----------------------------------------------------------------------===//

 }
 unsigned LLVMType::getArrayNumElements() {
   return getUnderlyingType()->getArrayNumElements();
 }
 bool LLVMType::isArrayTy() { return getUnderlyingType()->isArrayTy(); }
 
 /// Vector type utilities.
 LLVMType LLVMType::getVectorElementType() {
-  return get(getContext(), getUnderlyingType()->getVectorElementType());
+  return get(
+      getContext(),
+      llvm::cast<llvm::VectorType>(getUnderlyingType())->getElementType());
 }
 bool LLVMType::isVectorTy() { return getUnderlyingType()->isVectorTy(); }
 
 /// Function type utilities.
 LLVMType LLVMType::getFunctionParamType(unsigned argIdx) {
   return get(getContext(), getUnderlyingType()->getFunctionParamType(argIdx));
 }
 unsigned LLVMType::getFunctionNumParams() {

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

LLVMType Importer::processType(llvm::Type *type) {
   }
   case llvm::Type::ArrayTyID: {
     LLVMType elementType = processType(type->getArrayElementType());
     if (!elementType)
       return nullptr;
     return LLVMType::getArrayTy(elementType, type->getArrayNumElements());
   }
   case llvm::Type::VectorTyID: {
-    if (type->getVectorIsScalable()) {
+    auto *typeVTy = llvm::cast<llvm::VectorType>(type);
+    if (typeVTy->isScalable()) {
       emitError(unknownLoc) << "scalable vector types not supported";
       return nullptr;
     }
-    LLVMType elementType = processType(type->getVectorElementType());
+    LLVMType elementType = processType(typeVTy->getElementType());
     if (!elementType)
       return nullptr;
-    return LLVMType::getVectorTy(elementType, type->getVectorNumElements());
+    return LLVMType::getVectorTy(elementType, typeVTy->getNumElements());
   }
   case llvm::Type::VoidTyID:
     return LLVMType::getVoidTy(dialect);
   case llvm::Type::FP128TyID:
     return LLVMType::getFP128Ty(dialect);
   case llvm::Type::X86_FP80TyID:
     return LLVMType::getX86_FP80Ty(dialect);
   case llvm::Type::StructTyID: {
Type Importer::getStdTypeForAttr(LLVMType type) {
   if (type.getUnderlyingType()->isFloatTy())
     return b.getF32Type();
 
   if (type.getUnderlyingType()->isDoubleTy())
     return b.getF64Type();
 
   // LLVM vectors can only contain scalars.
   if (type.isVectorTy()) {
-    auto numElements = type.getUnderlyingType()->getVectorElementCount();
+    auto numElements = llvm::cast<llvm::VectorType>(type.getUnderlyingType())
+                           ->getElementCount();
     if (numElements.Scalable) {
       emitError(unknownLoc) << "scalable vectors not supported";
       return nullptr;
     }
     Type elementType = getStdTypeForAttr(type.getVectorElementType());
     if (!elementType)
       return nullptr;
     return VectorType::get(numElements.Min, elementType);
while (type.getArrayElementType().isArrayTy()) {
       shape.push_back(type.getArrayNumElements());
     }
 
     // If the innermost type is a vector, use the multi-dimensional vector as
     // attribute type.
     if (type.getArrayElementType().isVectorTy()) {
       LLVMType vectorType = type.getArrayElementType();
       auto numElements =
-          vectorType.getUnderlyingType()->getVectorElementCount();
+          llvm::cast<llvm::VectorType>(vectorType.getUnderlyingType())
+              ->getElementCount();
       if (numElements.Scalable) {
         emitError(unknownLoc) << "scalable vectors not supported";
         return nullptr;
       }
       shape.push_back(numElements.Min);
 
       Type elementType = getStdTypeForAttr(vectorType.getVectorElementType());
       if (!elementType)