Use vectorShape instead of vectorWidth

[asaadaldien]

Summary

This fixes build break

[pifon2a]

Thank you, Ahmed. I submitted smth like that already https://github.com/llvm/llvm-project/commit/a9a0ea92d13c20227c03b212d2dfa6a41a21ea6f

[asaadaldien]

In D112570#3088511, @pifon2a wrote:

Thank you, Ahmed. I submitted smth like that already https://github.com/llvm/llvm-project/commit/a9a0ea92d13c20227c03b212d2dfa6a41a21ea6f

Thanks Alex, dropping this diff

mlir/lib/Dialect/Math/Transforms/PolynomialApproximation.cpp

static Value exp2I32(ImplicitLocOpBuilder &builder, Value arg) {
   Value exp2ValueF32 = builder.create<arith::BitcastOp>(f32Vec, exp2ValueInt);
 
   return exp2ValueF32;
 }
 
 namespace {
 Value makePolynomialCalculation(ImplicitLocOpBuilder &builder,
                                 llvm::ArrayRef<Value> coeffs, Value x) {
-  auto width = vectorWidth(x.getType(), isF32);
+  auto shape = vectorShape(x.getType(), isF32);
   if (coeffs.size() == 0) {
-    return broadcast(builder, f32Cst(builder, 0.0f), *width);
+    return broadcast(builder, f32Cst(builder, 0.0f), *shape);
   } else if (coeffs.size() == 1) {
     return coeffs[0];
   }
   Value res = builder.create<math::FmaOp>(x, coeffs[coeffs.size() - 1],
                                           coeffs[coeffs.size() - 2]);
   for (auto i = ptrdiff_t(coeffs.size()) - 3; i >= 0; --i) {
     res = builder.create<math::FmaOp>(x, res, coeffs[i]);
   }

 // where P and Q are polynomials of degree 4.
 // Different coefficients are chosen based on the value of x.
 // The approximation error is ~2.5e-07.
 // Boost's minimax tool that utilizes the Remez method was used to find the
 // coefficients.
 LogicalResult
 ErfPolynomialApproximation::matchAndRewrite(math::ErfOp op,
                                             PatternRewriter &rewriter) const {
-  auto width = vectorWidth(op.operand().getType(), isF32);
-  if (!width.hasValue())
+  auto shape = vectorShape(op.operand().getType(), isF32);
+  if (!shape.hasValue())
     return rewriter.notifyMatchFailure(op, "unsupported operand type");
 
   ImplicitLocOpBuilder builder(op->getLoc(), rewriter);
   auto bcast = [&](Value value) -> Value {
-    return broadcast(builder, value, *width);
+    return broadcast(builder, value, *shape);
   };
 
   const int intervalsCount = 3;
   const int polyDegree = 4;
 
   Value zero = bcast(f32Cst(builder, 0));
   Value one = bcast(f32Cst(builder, 1));
   Value pp[intervalsCount][polyDegree + 1];