[mlir][NFC] Use initializers in if statement.

[jacquesguan]

Summary

Since we support C++17 now, we could use initializers in if statement to
simplify scope.

[rriddle]

I'm not convinced that this is an improvement, and I've personally already seen quite a few colleagues accidentally write these incorrectly for nullable things. I'd rather keep these as-is.

[jpienaar]

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

631

Agreed with River, the previous form I find clearer in cases like this.

[mehdi_amini]

Seems like something that should be raised to the community and codify in the style guide instead of solved on a per-review basis.

[jacquesguan]

In D134027#3797706, @mehdi_amini wrote:

Seems like something that should be raised to the community and codify in the style guide instead of solved on a per-review basis.

https://discourse.llvm.org/t/code-style-of-initializer-in-if-statement/65357 OK, I created a topic in the community.

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::AddIOp::fold(ArrayRef<Attribute> operands) {
   // addi(x, 0) -> x
   if (matchPattern(getRhs(), m_Zero()))
     return getLhs();
 
   // addi(subi(a, b), b) -> a
-  if (auto sub = getLhs().getDefiningOp<SubIOp>())
-    if (getRhs() == sub.getRhs())
-      return sub.getLhs();
+  if (auto sub = getLhs().getDefiningOp<SubIOp>();
+      sub && getRhs() == sub.getRhs())
 
   // addi(b, subi(a, b)) -> a
-  if (auto sub = getRhs().getDefiningOp<SubIOp>())
-    if (getLhs() == sub.getRhs())
-      return sub.getLhs();
+  if (auto sub = getRhs().getDefiningOp<SubIOp>();
+      sub && getLhs() == sub.getRhs())
 
   return constFoldBinaryOp<IntegerAttr>(
       operands, [](APInt a, const APInt &b) { return std::move(a) + b; });
 }
 
 void arith::AddIOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                 MLIRContext *context) {
   patterns.add<AddIAddConstant, AddISubConstantRHS, AddISubConstantLHS>(

 // OrIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::OrIOp::fold(ArrayRef<Attribute> operands) {
   /// or(x, 0) -> x
   if (matchPattern(getRhs(), m_Zero()))
     return getLhs();
   /// or(x, <all ones>) -> <all ones>
-  if (auto rhsAttr = operands[1].dyn_cast_or_null<IntegerAttr>())
-    if (rhsAttr.getValue().isAllOnes())
-      return rhsAttr;
+  if (auto rhsAttr = operands[1].dyn_cast_or_null<IntegerAttr>();
+      rhsAttr && rhsAttr.getValue().isAllOnes())
 
   return constFoldBinaryOp<IntegerAttr>(
       operands, [](APInt a, const APInt &b) { return std::move(a) | b; });
 }
 
 //===----------------------------------------------------------------------===//
 // XOrIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::XOrIOp::fold(ArrayRef<Attribute> operands) {
   /// xor(x, 0) -> x
   if (matchPattern(getRhs(), m_Zero()))
     return getLhs();
   /// xor(x, x) -> 0
   if (getLhs() == getRhs())
     return Builder(getContext()).getZeroAttr(getType());
   /// xor(xor(x, a), a) -> x
-  if (arith::XOrIOp prev = getLhs().getDefiningOp<arith::XOrIOp>())
-    if (prev.getRhs() == getRhs())
-      return prev.getLhs();
+  if (arith::XOrIOp prev = getLhs().getDefiningOp<arith::XOrIOp>();
+      prev && prev.getRhs() == getRhs())
 
   return constFoldBinaryOp<IntegerAttr>(
       operands, [](APInt a, const APInt &b) { return std::move(a) ^ b; });
 }
 
 void arith::XOrIOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                 MLIRContext *context) {
   patterns.add<XOrINotCmpI>(context);
OpFoldResult arith::CmpIOp::fold(ArrayRef<Attribute> 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>()) {
-      // extsi(%x : i1 -> iN) != 0  ->  %x
-      if (extOp.getOperand().getType().cast<IntegerType>().getWidth() == 1 &&
-          getPredicate() == arith::CmpIPredicate::ne)
-        return extOp.getOperand();
-    }
-    if (auto extOp = getLhs().getDefiningOp<ExtUIOp>()) {
-      // extui(%x : i1 -> iN) != 0  ->  %x
-      if (extOp.getOperand().getType().cast<IntegerType>().getWidth() == 1 &&
-          getPredicate() == arith::CmpIPredicate::ne)
-        return extOp.getOperand();
-    }
-  }
+    if (auto extOp = getLhs().getDefiningOp<ExtSIOp>();
+        extOp && extOp.getOperand().getType().cast<IntegerType>().getWidth() == 1 &&
+
+    if (auto extOp = getLhs().getDefiningOp<ExtUIOp>();
+        extOp && extOp.getOperand().getType().cast<IntegerType>().getWidth() == 1 &&
 
   // Move constant to the right side.
   if (operands[0] && !operands[1]) {
     // Do not use invertPredicate, as it will change eq to ne and vice versa.
     using Pred = CmpIPredicate;
     const std::pair<Pred, Pred> invPreds[] = {
         {Pred::slt, Pred::sgt}, {Pred::sgt, Pred::slt}, {Pred::sle, Pred::sge},
         {Pred::sge, Pred::sle}, {Pred::ult, Pred::ugt}, {Pred::ugt, Pred::ult},
LogicalResult matchAndRewrite(CmpFOp op,
     // Number of bits representing values, as opposed to the sign
     auto valueBits = isUnsigned ? intWidth : (intWidth - 1);
 
     // Following test does NOT adjust intWidth downwards for signed inputs,
     // because the most negative value still requires all the mantissa bits
     // to distinguish it from one less than that value.
     if ((int)intWidth > mantissaWidth) {
       // Conversion would lose accuracy. Check if loss can impact comparison.
-      int exponent = ilogb(rhs);
-      if (exponent == APFloat::IEK_Inf) {
-        int maxExponent = ilogb(APFloat::getLargest(rhs.getSemantics()));
-        if (maxExponent < (int)valueBits) {
+      if (int exponent = ilogb(rhs); exponent == APFloat::IEK_Inf) {
+        if (int maxExponent = ilogb(APFloat::getLargest(rhs.getSemantics()));
+            maxExponent < (int)valueBits) {
           // Conversion could create infinity.
           return failure();
         }
       } else {
         // Note that if rhs is zero or NaN, then Exp is negative
         // and first condition is trivially false.
         if (mantissaWidth <= exponent && exponent <= (int)valueBits) {
           // Conversion could affect comparison.
if (matchPattern(condition, m_Zero()))
     return falseVal;
 
   // select %x, true, false => %x
   if (getType().isInteger(1) && matchPattern(getTrueValue(), m_One()) &&
       matchPattern(getFalseValue(), m_Zero()))
     return condition;
 
   if (auto cmp = dyn_cast_or_null<arith::CmpIOp>(condition.getDefiningOp())) {
-    auto pred = cmp.getPredicate();
-    if (pred == arith::CmpIPredicate::eq || pred == arith::CmpIPredicate::ne) {
+    if (auto pred = cmp.getPredicate();
+        pred == arith::CmpIPredicate::eq || pred == arith::CmpIPredicate::ne) {
       auto cmpLhs = cmp.getLhs();
       auto cmpRhs = cmp.getRhs();
 
       // %0 = arith.cmpi eq, %arg0, %arg1
       // %1 = arith.select %0, %arg0, %arg1 => %arg1
 
       // %0 = arith.cmpi ne, %arg0, %arg1
       // %1 = arith.select %0, %arg0, %arg1 => %arg0