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

Reviewed By: wrengr, Peiming Differential Revision: https://reviews.llvm.org/D136878

Author: aartbik

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

@@ -869,7 +869,7 @@ Type Merger::inferType(unsigned e, Value src) {
 }
 
 /// 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;
@@ -883,19 +883,19 @@ static bool isAdmissableBranchExp(Operation *op, Block *block, Value v) {
  // 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) {
@@ -989,12 +989,12 @@ Optional<unsigned> Merger::buildTensorExp(linalg::GenericOp op, Value v) {
  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);
  }
  }
@@ -1047,11 +1047,11 @@ Optional<unsigned> Merger::buildTensorExp(linalg::GenericOp op, Value v) {
  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);
  }
  }
@@ -1065,7 +1065,7 @@ Optional<unsigned> Merger::buildTensorExp(linalg::GenericOp op, Value v) {
  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);
  }
  }