[mlir] Clean up ArithToLLVM. NFC.

[kuhar]

Summary

Based on @Mogball's feedback in https://reviews.llvm.org/D132613.

[dcaballe]

Thanks for the cleanup, @kuhar! LGTM.

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

 using XOrIOpLowering = VectorConvertToLLVMPattern<arith::XOrIOp, LLVM::XOrOp>;
 
 //===----------------------------------------------------------------------===//
 // Op Lowering Patterns
 //===----------------------------------------------------------------------===//
 
 /// Directly lower to LLVM op.
 struct ConstantOpLowering : public ConvertOpToLLVMPattern<arith::ConstantOp> {
-  using ConvertOpToLLVMPattern<arith::ConstantOp>::ConvertOpToLLVMPattern;
+  using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(arith::ConstantOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// The lowering of index_cast becomes an integer conversion since index
 /// becomes an integer.  If the bit width of the source and target integer
 /// types is the same, just erase the cast.  If the target type is wider,
 /// sign-extend the value, otherwise truncate it.
 struct IndexCastOpLowering : public ConvertOpToLLVMPattern<arith::IndexCastOp> {
-  using ConvertOpToLLVMPattern<arith::IndexCastOp>::ConvertOpToLLVMPattern;
+  using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(arith::IndexCastOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 struct CmpIOpLowering : public ConvertOpToLLVMPattern<arith::CmpIOp> {
-  using ConvertOpToLLVMPattern<arith::CmpIOp>::ConvertOpToLLVMPattern;
+  using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(arith::CmpIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 struct CmpFOpLowering : public ConvertOpToLLVMPattern<arith::CmpFOp> {
-  using ConvertOpToLLVMPattern<arith::CmpFOp>::ConvertOpToLLVMPattern;
+  using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(arith::CmpFOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 } // namespace
 

 
 //===----------------------------------------------------------------------===//
 // IndexCastOpLowering
 //===----------------------------------------------------------------------===//
 
 LogicalResult IndexCastOpLowering::matchAndRewrite(
     arith::IndexCastOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
-  auto resultType = op.getResult().getType();
-  auto targetElementType =
+  Type resultType = op.getResult().getType();
+  Type targetElementType =
       typeConverter->convertType(getElementTypeOrSelf(resultType));
-  auto sourceElementType =
+  Type sourceElementType =
       typeConverter->convertType(getElementTypeOrSelf(op.getIn()));
   unsigned targetBits = targetElementType.getIntOrFloatBitWidth();
   unsigned sourceBits = sourceElementType.getIntOrFloatBitWidth();
 
   if (targetBits == sourceBits) {
     rewriter.replaceOp(op, adaptor.getIn());
     return success();
   }
 
   // Handle the scalar and 1D vector cases.
-  auto operandType = adaptor.getIn().getType();
+  Type operandType = adaptor.getIn().getType();
   if (!operandType.isa<LLVM::LLVMArrayType>()) {
-    auto targetType = typeConverter->convertType(resultType);
+    Type targetType = typeConverter->convertType(resultType);
     if (targetBits < sourceBits)
       rewriter.replaceOpWithNewOp<LLVM::TruncOp>(op, targetType,
                                                  adaptor.getIn());
     else
       rewriter.replaceOpWithNewOp<LLVM::SExtOp>(op, targetType,
                                                 adaptor.getIn());
     return success();
   }
 
-  auto vectorType = resultType.dyn_cast<VectorType>();
-  if (!vectorType)
+  if (!resultType.isa<VectorType>())
     return rewriter.notifyMatchFailure(op, "expected vector result type");
 
   return LLVM::detail::handleMultidimensionalVectors(
       op.getOperation(), adaptor.getOperands(), *getTypeConverter(),
       [&](Type llvm1DVectorTy, ValueRange operands) -> Value {
         OpAdaptor adaptor(operands);
         if (targetBits < sourceBits) {
           return rewriter.create<LLVM::TruncOp>(op.getLoc(), llvm1DVectorTy,

 template <typename LLVMPredType, typename PredType>
 static LLVMPredType convertCmpPredicate(PredType pred) {
   return static_cast<LLVMPredType>(pred);
 }
 
 LogicalResult
 CmpIOpLowering::matchAndRewrite(arith::CmpIOp op, OpAdaptor adaptor,
                                 ConversionPatternRewriter &rewriter) const {
-  auto operandType = adaptor.getLhs().getType();
-  auto resultType = op.getResult().getType();
+  Type operandType = adaptor.getLhs().getType();
+  Type resultType = op.getResult().getType();
 
   // Handle the scalar and 1D vector cases.
   if (!operandType.isa<LLVM::LLVMArrayType>()) {
     rewriter.replaceOpWithNewOp<LLVM::ICmpOp>(
         op, typeConverter->convertType(resultType),
         convertCmpPredicate<LLVM::ICmpPredicate>(op.getPredicate()),
         adaptor.getLhs(), adaptor.getRhs());
     return success();
   }
 
-  auto vectorType = resultType.dyn_cast<VectorType>();
-  if (!vectorType)
+  if (!resultType.isa<VectorType>())
     return rewriter.notifyMatchFailure(op, "expected vector result type");
 
   return LLVM::detail::handleMultidimensionalVectors(
       op.getOperation(), adaptor.getOperands(), *getTypeConverter(),
       [&](Type llvm1DVectorTy, ValueRange operands) {
         OpAdaptor adaptor(operands);
         return rewriter.create<LLVM::ICmpOp>(
             op.getLoc(), llvm1DVectorTy,
             convertCmpPredicate<LLVM::ICmpPredicate>(op.getPredicate()),
             adaptor.getLhs(), adaptor.getRhs());
       },
       rewriter);
 }
 
 //===----------------------------------------------------------------------===//
 // CmpFOpLowering
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 CmpFOpLowering::matchAndRewrite(arith::CmpFOp op, OpAdaptor adaptor,
                                 ConversionPatternRewriter &rewriter) const {
-  auto operandType = adaptor.getLhs().getType();
-  auto resultType = op.getResult().getType();
+  Type operandType = adaptor.getLhs().getType();
+  Type resultType = op.getResult().getType();
 
   // Handle the scalar and 1D vector cases.
   if (!operandType.isa<LLVM::LLVMArrayType>()) {
     rewriter.replaceOpWithNewOp<LLVM::FCmpOp>(
         op, typeConverter->convertType(resultType),
         convertCmpPredicate<LLVM::FCmpPredicate>(op.getPredicate()),
         adaptor.getLhs(), adaptor.getRhs());
     return success();
   }
 
-  auto vectorType = resultType.dyn_cast<VectorType>();
-  if (!vectorType)
+  if (!resultType.isa<VectorType>())
     return rewriter.notifyMatchFailure(op, "expected vector result type");
 
   return LLVM::detail::handleMultidimensionalVectors(
       op.getOperation(), adaptor.getOperands(), *getTypeConverter(),
       [&](Type llvm1DVectorTy, ValueRange operands) {
         OpAdaptor adaptor(operands);
         return rewriter.create<LLVM::FCmpOp>(
             op.getLoc(), llvm1DVectorTy,