[MLIR][Arith] Remove unused assertions

[Miss_Grape]

Summary

We shouldn't be checking things that are guaranteed by the op's verifier.

[benshi001]

LGTM

[ftynse]

This change feels contrary to the LLVM developer guide - https://llvm.org/docs/CodingStandards.html#assert-liberally. There are plenty of places in MLIR where we assert things already checked by the verifier, for the very simple reason: verifiers are not set in stone. A change in op structure can easily lead to verifiers changing and these asserts suddenly become useful. Simple examples for these ops specifically; we may want min/max of an arbitrary number of operands rather than just two.

Please revert.

If you think this change is desired, please make a better case for that and request review from people with the history of contributions to this part of the code.

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

return constFoldBinaryOp<FloatAttr>(
       operands, [](const APFloat &a, const APFloat &b) { return a - b; });
 }
 
 //===----------------------------------------------------------------------===//
 // MaxFOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::MaxFOp::fold(ArrayRef<Attribute> operands) {
-  assert(operands.size() == 2 && "maxf takes two operands");
-
   // maxf(x,x) -> x
   if (getLhs() == getRhs())
     return getRhs();
 
   // maxf(x, -inf) -> x
   if (matchPattern(getRhs(), m_NegInfFloat()))
     return getLhs();
 
   return constFoldBinaryOp<FloatAttr>(
       operands,
       [](const APFloat &a, const APFloat &b) { return llvm::maximum(a, b); });
 }
 
 //===----------------------------------------------------------------------===//
 // MaxSIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult MaxSIOp::fold(ArrayRef<Attribute> operands) {
-  assert(operands.size() == 2 && "binary operation takes two operands");
-
   // maxsi(x,x) -> x
   if (getLhs() == getRhs())
     return getRhs();
 
   APInt intValue;
   // maxsi(x,MAX_INT) -> MAX_INT
   if (matchPattern(getRhs(), m_ConstantInt(&intValue)) &&
       intValue.isMaxSignedValue())
return constFoldBinaryOp<IntegerAttr>(operands,
                                         });
 }
 
 //===----------------------------------------------------------------------===//
 // MaxUIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult MaxUIOp::fold(ArrayRef<Attribute> operands) {
-  assert(operands.size() == 2 && "binary operation takes two operands");
-
   // maxui(x,x) -> x
   if (getLhs() == getRhs())
     return getRhs();
 
   APInt intValue;
   // maxui(x,MAX_INT) -> MAX_INT
   if (matchPattern(getRhs(), m_ConstantInt(&intValue)) && intValue.isMaxValue())
     return getRhs();
 
   // maxui(x, MIN_INT) -> x
   if (matchPattern(getRhs(), m_ConstantInt(&intValue)) && intValue.isMinValue())
     return getLhs();
 
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](const APInt &a, const APInt &b) {
                                           return llvm::APIntOps::umax(a, b);
                                         });
 }
 
 //===----------------------------------------------------------------------===//
 // MinFOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::MinFOp::fold(ArrayRef<Attribute> operands) {
-  assert(operands.size() == 2 && "minf takes two operands");
-
   // minf(x,x) -> x
   if (getLhs() == getRhs())
     return getRhs();
 
   // minf(x, +inf) -> x
   if (matchPattern(getRhs(), m_PosInfFloat()))
     return getLhs();
 
   return constFoldBinaryOp<FloatAttr>(
       operands,
       [](const APFloat &a, const APFloat &b) { return llvm::minimum(a, b); });
 }
 
 //===----------------------------------------------------------------------===//
 // MinSIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult MinSIOp::fold(ArrayRef<Attribute> operands) {
-  assert(operands.size() == 2 && "binary operation takes two operands");
-
   // minsi(x,x) -> x
   if (getLhs() == getRhs())
     return getRhs();
 
   APInt intValue;
   // minsi(x,MIN_INT) -> MIN_INT
   if (matchPattern(getRhs(), m_ConstantInt(&intValue)) &&
       intValue.isMinSignedValue())
return constFoldBinaryOp<IntegerAttr>(operands,
                                         });
 }
 
 //===----------------------------------------------------------------------===//
 // MinUIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult MinUIOp::fold(ArrayRef<Attribute> operands) {
-  assert(operands.size() == 2 && "binary operation takes two operands");
-
   // minui(x,x) -> x
   if (getLhs() == getRhs())
     return getRhs();
 
   APInt intValue;
   // minui(x,MIN_INT) -> MIN_INT
   if (matchPattern(getRhs(), m_ConstantInt(&intValue)) && intValue.isMinValue())
     return getRhs();

 
 LogicalResult arith::ExtFOp::verify() { return verifyExtOp<FloatType>(*this); }
 
 //===----------------------------------------------------------------------===//
 // TruncIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::TruncIOp::fold(ArrayRef<Attribute> operands) {
-  assert(operands.size() == 1 && "unary operation takes one operand");
-
   // trunci(zexti(a)) -> a
   // trunci(sexti(a)) -> a
   if (matchPattern(getOperand(), m_Op<arith::ExtUIOp>()) ||
       matchPattern(getOperand(), m_Op<arith::ExtSIOp>()))
     return getOperand().getDefiningOp()->getOperand(0);
 
   // trunci(trunci(a)) -> trunci(a))
   if (matchPattern(getOperand(), m_Op<arith::TruncIOp>())) {

 
 //===----------------------------------------------------------------------===//
 // TruncFOp
 //===----------------------------------------------------------------------===//
 
 /// Perform safe const propagation for truncf, i.e. only propagate if FP value
 /// can be represented without precision loss or rounding.
 OpFoldResult arith::TruncFOp::fold(ArrayRef<Attribute> operands) {
-  assert(operands.size() == 1 && "unary operation takes one operand");
-
   auto constOperand = operands.front();
   if (!constOperand || !constOperand.isa<FloatAttr>())
     return {};
 
   // Convert to target type via 'double'.
   double sourceValue =
       constOperand.dyn_cast<FloatAttr>().getValue().convertToDouble();
   auto targetAttr = FloatAttr::get(getType(), sourceValue);
auto dstType =
       getTypeIfLikeOrMemRef<IntegerType, IndexType, FloatType>(outputs.front());
   if (!srcType || !dstType)
     return false;
 
   return srcType.getIntOrFloatBitWidth() == dstType.getIntOrFloatBitWidth();
 }
 
 OpFoldResult arith::BitcastOp::fold(ArrayRef<Attribute> operands) {
-  assert(operands.size() == 1 && "bitcast op expects 1 operand");
-
   auto resType = getType();
   auto operand = operands[0];
   if (!operand)
     return {};
 
   /// Bitcast dense elements.
   if (auto denseAttr = operand.dyn_cast_or_null<DenseElementsAttr>())
     return denseAttr.bitcast(resType.cast<ShapedType>().getElementType());
static std::optional<int64_t> getIntegerWidth(Type t) {
   }
   if (auto vectorIntType = t.dyn_cast<VectorType>()) {
     return vectorIntType.getElementType().cast<IntegerType>().getWidth();
   }
   return std::nullopt;
 }
 
 OpFoldResult arith::CmpIOp::fold(ArrayRef<Attribute> operands) {
-  assert(operands.size() == 2 && "cmpi takes two operands");
-
   // cmpi(pred, x, x)
   if (getLhs() == getRhs()) {
     auto val = applyCmpPredicateToEqualOperands(getPredicate());
     return getBoolAttribute(getType(), getContext(), val);
   }
 
   if (matchPattern(getRhs(), m_Zero())) {
     if (auto extOp = getLhs().getDefiningOp<ExtSIOp>()) {
case arith::CmpFPredicate::UNO:
     return cmpResult == APFloat::cmpUnordered;
   case arith::CmpFPredicate::AlwaysTrue:
     return true;
   }
   llvm_unreachable("unknown cmpf predicate kind");
 }
 
 OpFoldResult arith::CmpFOp::fold(ArrayRef<Attribute> operands) {
-  assert(operands.size() == 2 && "cmpf takes two operands");
-
   auto lhs = operands.front().dyn_cast_or_null<FloatAttr>();
   auto rhs = operands.back().dyn_cast_or_null<FloatAttr>();
 
   // If one operand is NaN, making them both NaN does not change the result.
   if (lhs && lhs.getValue().isNaN())
     rhs = lhs;
   if (rhs && rhs.getValue().isNaN())
     lhs = rhs;