[mlir][sparse] fix typo "admissable" -> "admissible"

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

Type Merger::inferType(unsigned e, Value src) {
   // Inspect source type. For vector types, apply the same
   // vectorization to the destination type.
   if (auto vtp = src.getType().dyn_cast<VectorType>())
     return VectorType::get(vtp.getNumElements(), dtp, vtp.getNumScalableDims());
   return dtp;
 }
 
 /// Ensures that sparse compiler can generate code for expression.
-static bool isAdmissableBranchExp(Operation *op, Block *block, Value v) {
+static bool isAdmissibleBranchExp(Operation *op, Block *block, Value v) {
   // Arguments are always admissible.
   if (auto arg = v.dyn_cast<BlockArgument>())
     return true;
   // Accept index anywhere.
   Operation *def = v.getDefiningOp();
   if (isa<linalg::IndexOp>(def))
     return true;
   // Operation defined outside branch.
   if (def->getBlock() != block)
     return def->getBlock() != op->getBlock(); // invariant?
   // Operation defined within branch. Anything is accepted,
   // as long as all subexpressions are admissible.
   for (unsigned i = 0, n = def->getNumOperands(); i < n; i++)
-    if (!isAdmissableBranchExp(op, block, def->getOperand(i)))
+    if (!isAdmissibleBranchExp(op, block, def->getOperand(i)))
       return false;
   return true;
 }
 
 /// Ensures that sparse compiler can generate code for branch.
-static bool isAdmissableBranch(Operation *op, Region &region) {
+static bool isAdmissibleBranch(Operation *op, Region &region) {
   if (region.empty())
     return true;
   // Build the semi-ring branch semantics backward from yield.
   Operation *yield = region.front().getTerminator();
   assert(isa<YieldOp>(yield));
-  return isAdmissableBranchExp(op, &region.front(), yield->getOperand(0));
+  return isAdmissibleBranchExp(op, &region.front(), yield->getOperand(0));
 }
 
 Optional<unsigned> Merger::buildTensorExp(linalg::GenericOp op, Value v) {
   if (auto arg = v.dyn_cast<BlockArgument>()) {
     unsigned argN = arg.getArgNumber();
     // Any argument of the generic op that is not marked as a scalar
     // argument is considered a tensor, indexed by the implicit loop
     // bounds. This includes rank-0 tensor arguments.
if (x.has_value()) {
         return addExp(kTruncI, e, v);
       if (isa<complex::ImOp>(def))
         return addExp(kCIm, e);
       if (isa<complex::ReOp>(def))
         return addExp(kCRe, e);
       if (isa<arith::BitcastOp>(def))
         return addExp(kBitCast, e, v);
       if (auto unop = dyn_cast<sparse_tensor::UnaryOp>(def)) {
-        if (isAdmissableBranch(unop, unop.getPresentRegion()) &&
-            isAdmissableBranch(unop, unop.getAbsentRegion()))
+        if (isAdmissibleBranch(unop, unop.getPresentRegion()) &&
+            isAdmissibleBranch(unop, unop.getAbsentRegion()))
           return addExp(kUnary, e, Value(), def);
       }
       if (auto selop = dyn_cast<sparse_tensor::SelectOp>(def)) {
-        if (isAdmissableBranch(selop, selop.getRegion()))
+        if (isAdmissibleBranch(selop, selop.getRegion()))
           return addExp(kSelect, e, Value(), def);
       }
     }
   }
   // Construct binary operations if subexpressions can be built.
   // See buildLattices() for an explanation of rejecting certain
   // division and shift operations.
   if (def->getNumOperands() == 2) {
if (x.has_value() && y.has_value()) {
         return addExp(kXorI, e0, e1);
       if (isa<arith::ShRSIOp>(def) && isInvariant(e1))
         return addExp(kShrS, e0, e1);
       if (isa<arith::ShRUIOp>(def) && isInvariant(e1))
         return addExp(kShrU, e0, e1);
       if (isa<arith::ShLIOp>(def) && isInvariant(e1))
         return addExp(kShlI, e0, e1);
       if (auto binop = dyn_cast<sparse_tensor::BinaryOp>(def)) {
-        if (isAdmissableBranch(binop, binop.getOverlapRegion()) &&
+        if (isAdmissibleBranch(binop, binop.getOverlapRegion()) &&
             (binop.getLeftIdentity() ||
-             isAdmissableBranch(binop, binop.getLeftRegion())) &&
+             isAdmissibleBranch(binop, binop.getLeftRegion())) &&
             (binop.getRightIdentity() ||
-             isAdmissableBranch(binop, binop.getRightRegion())))
+             isAdmissibleBranch(binop, binop.getRightRegion())))
           return addExp(kBinary, e0, e1, Value(), def);
       }
     }
   }
   // Construct ternary operations if subexpressions can be built.
   if (def->getNumOperands() == 3) {
     auto x = buildTensorExp(op, def->getOperand(0));
     auto y = buildTensorExp(op, def->getOperand(1));
     auto z = buildTensorExp(op, def->getOperand(2));
     if (x.has_value() && y.has_value() && z.has_value()) {
       unsigned e0 = x.value();
       unsigned e1 = y.value();
       if (auto redop = dyn_cast<sparse_tensor::ReduceOp>(def)) {
-        if (isAdmissableBranch(redop, redop.getRegion()))
+        if (isAdmissibleBranch(redop, redop.getRegion()))
           return addExp(kReduce, e0, e1, Value(), def);
       }
     }
   }
   // Cannot build.
   return None;
 }