[mlir][sparse] Factoring out Merger::expIsTensor

[wrengr]

Summary

Depends On D145611

mlir/include/mlir/Dialect/SparseTensor/Utils/Merger.h

public:
   /// expressions).
   unsigned getSynTensorID() const { return syntheticTensor; }
 
   bool isFilterLoop(unsigned ldx) const {
     assert(ldx < numLoops);
     return ldx >= numNativeLoops;
   }
 
+  /// Returns true if the expression is `(kTensor t)`.
+  bool expIsTensor(unsigned e, unsigned t) const {
+    return tensorExps[e].kind == kTensor && tensorExps[e].tensor == t;
+  }
+
   /// Returns true if the expression contains the `t` as an operand.
   bool expContainsTensor(unsigned e, unsigned t) const;
 
   /// Returns true if the expression contains a negation on output tensor.
   /// I.e., `- outTensor` or `exp - outputTensor`
   /// NOTE: this is an trivial tests in that it does not handle recursive
   /// negation, i.e., it returns true when the expression is `-(-tensor)`.
   bool hasNegateOnOut(unsigned e) const;

mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp

unsigned Merger::optimizeSet(unsigned s0) {
   unsigned s = addSet();
   assert(!latSets[s0].empty());
   unsigned p0 = latSets[s0][0];
   for (unsigned p1 : latSets[s0]) {
     bool add = true;
     if (p0 != p1) {
       // Is this a straightforward copy?
       unsigned e = latPoints[p1].exp;
-      if (tensorExps[e].kind == kTensor && tensorExps[e].tensor == outTensor)
+      if (expIsTensor(e, outTensor))
         continue;
       // Conjunction already covered?
       for (unsigned p2 : latSets[s]) {
         assert(!latGT(p1, p2)); // Lj => Li would be bad
         if (onlyDenseDiff(p2, p1)) {
           add = false;
           break;
         }
bool Merger::expContainsTensor(unsigned e, unsigned t) const {
   if (tensorExps[e].kind == kTensor)
     return tensorExps[e].tensor == t;
 
   switch (getExpArity(tensorExps[e].kind)) {
   case ExpArity::kNullary:
     return false;
   case ExpArity::kUnary: {
     unsigned op = tensorExps[e].children.e0;
-    if (tensorExps[op].kind == kTensor && tensorExps[op].tensor == t)
+    if (expIsTensor(op, t))
       return true;
     return expContainsTensor(op, t);
   }
   case ExpArity::kBinary: {
     unsigned op1 = tensorExps[e].children.e0;
     unsigned op2 = tensorExps[e].children.e1;
-    if ((tensorExps[op1].kind == kTensor && tensorExps[op1].tensor == t) ||
-        (tensorExps[op2].kind == kTensor && tensorExps[op2].tensor == t))
+    if (expIsTensor(op1, t) || expIsTensor(op2, t))
       return true;
     return expContainsTensor(op1, t) || expContainsTensor(op2, t);
   }
   }
   llvm_unreachable("unexpected arity");
 }
 
 bool Merger::hasNegateOnOut(unsigned e) const {