diff --git a/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp b/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp
--- a/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp
+++ b/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp
@@ -869,7 +869,7 @@
 }
 
 /// 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 @@
   // 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 @@
       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 @@
       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 @@
       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);
       }
     }