[mlir][sparse] merge ifs in new sparse rewriting rules

[aartbik]

rebased main

[aartbik]

rebased again, presubmit keeps on failing with unrelated error

[aartbik]

rebased

[aartbik]

rebased main

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

for (unsigned i = 0, e = dimTypes.size(); i < e; i++)
         return true; // at least one compressed
   }
   return false;
 }
 
 // Helper method to find zero or empty initialization.
 static bool isEmptyInit(OpOperand *op) {
   Value val = op->get();
-  if (matchPattern(val, m_Zero()))
-    return true;
-  if (matchPattern(val, m_AnyZeroFloat()))
-    return true;
-  if (val.getDefiningOp<InitTensorOp>())
-    return true;
-  if (val.getDefiningOp<InitOp>())
-    return true;
-  return false;
+  return matchPattern(val, m_Zero()) || matchPattern(val, m_AnyZeroFloat()) ||
+         val.getDefiningOp<InitTensorOp>() || val.getDefiningOp<InitOp>();
 }
 
 // Helper to detect sampling operation.
 static bool isSampling(GenericOp op) {
   auto yieldOp = cast<linalg::YieldOp>(op.region().front().getTerminator());
   if (auto def = yieldOp.getOperand(0).getDefiningOp()) {
     if (isa<arith::MulFOp>(def) || isa<arith::MulIOp>(def)) {
       // Both scalar input arguments used exactly once.

 /// since intermediate results may be nullified.
 struct FuseSparseMultiplyOverAdd : public OpRewritePattern<GenericOp> {
   using OpRewritePattern<GenericOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(GenericOp op,
                                 PatternRewriter &rewriter) const override {
     // Check consumer.
     if (!op.hasTensorSemantics() || op.getNumInputs() != 2 ||
-        op.getNumResults() != 1)
-      return failure();
-    if (op.getNumParallelLoops() != op.getNumLoops())
-      return failure();
-    if (!op.getTiedIndexingMap(op.getOutputOperand(0)).isIdentity() ||
+        op.getNumResults() != 1 ||
+        op.getNumParallelLoops() != op.getNumLoops() ||
+        !op.getTiedIndexingMap(op.getOutputOperand(0)).isIdentity() ||
         !op.getTiedIndexingMap(op.getInputOperand(0)).isIdentity() ||
         !op.getTiedIndexingMap(op.getInputOperand(1)).isIdentity())
       return failure();
     // Find consuming OP2(sparse, other) or OP2(other, sparse). The other
     // operand can be sparse or dense, since the point of this rewriting rule
     // is detecting a situation in which *more* sparsity is introduced into
     // a computation, be it already sparse or still dense.
     unsigned other = 0;
     if (isSparseTensor(op.getInputOperand(0)))
       other = 1;
     else if (!isSparseTensor(op.getInputOperand(1)))
       return failure();
     // Check producer.
     auto prod = dyn_cast_or_null<GenericOp>(
         op.getInputOperand(other)->get().getDefiningOp());
-    if (!prod || !prod.hasTensorSemantics() || prod.getNumResults() != 1)
-      return failure();
-    if (!prod.getResult(0).hasOneUse())
+    if (!prod || !prod.hasTensorSemantics() || prod.getNumResults() != 1 ||
+        !prod.getResult(0).hasOneUse())
       return failure();
     // Sampling consumer and sum of multiplication chain producer.
     if (!isEmptyInit(op.getOutputOperand(0)) ||
-        !isEmptyInit(prod.getOutputOperand(0)))
-      return failure();
-    if (!isSampling(op) || !isSumOfMul(prod))
+        !isEmptyInit(prod.getOutputOperand(0)) || !isSampling(op) ||
+        !isSumOfMul(prod))
       return failure();
     // Modify operand structure of producer and consumer.
     Location loc = prod.getLoc();
     SmallVector<Value> inputOps = prod.getInputOperands();
     SmallVector<Value> outputOps = op.getOutputOperands();
     SmallVector<AffineMap> fusedIndexMaps = prod.getIndexingMaps();
     inputOps.push_back(op.getInputOperand(1 - other)->get());
     fusedIndexMaps.push_back(fusedIndexMaps.back()); // mimic other