[mlir][vector] Use optional for outerproduct accumulator instead of variadic

[c-rhodes]

Summary

This was introduced before the Optional directive and uses Variadic, but
it's really optional.

[benmxwl-arm]

LGTM 👍

[nicolasvasilache]

yes, thank you!

[dcaballe]

Thanks!

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

 def Vector_OuterProductOp :
   Vector_Op<"outerproduct", [Pure,
     PredOpTrait<"lhs operand and result have same element type",
                 TCresVTEtIsSameAsOpBase<0, 0>>,
     PredOpTrait<"rhs operand and result have same element type",
                 TCresVTEtIsSameAsOpBase<0, 1>>,
     DeclareOpInterfaceMethods<MaskableOpInterface>]>,
     Arguments<(ins AnyVector:$lhs, AnyType:$rhs,
-               Variadic<AnyVector>:$acc,
+               Optional<AnyVector>:$acc,
                DefaultValuedAttr<Vector_CombiningKindAttr, "CombiningKind::ADD">:$kind)>,
     Results<(outs AnyVector)> {
   let summary = "vector outerproduct with optional fused add";
   let description = [{
     Takes 2 1-D vectors and returns the 2-D vector containing the outer-product,
     as illustrated below:
     ```
      outer |   [c, d]
def Vector_OuterProductOp :
   let extraClassDeclaration = [{
     VectorType getOperandVectorTypeLHS() {
       return ::llvm::cast<VectorType>(getLhs().getType());
     }
     Type getOperandTypeRHS() {
       return getRhs().getType();
     }
     VectorType getOperandVectorTypeACC() {
-      return getAcc().empty()
-        ? VectorType()
-        : ::llvm::cast<VectorType>((*getAcc().begin()).getType());
+      return getAcc()
+        ? ::llvm::cast<VectorType>(getAcc().getType())
+        : VectorType();
     }
     VectorType getResultVectorType() {
       return ::llvm::cast<VectorType>(getResult().getType());
     }
     static CombiningKind getDefaultKind() {
       return CombiningKind::ADD;
     }
   }];

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

 void OuterProductOp::build(OpBuilder &builder, OperationState &result,
                            Value lhs, Value rhs, Value acc) {
   result.addOperands({lhs, rhs, acc});
   result.addTypes(acc.getType());
 }
 
 void OuterProductOp::print(OpAsmPrinter &p) {
   p << " " << getLhs() << ", " << getRhs();
-  if (!getAcc().empty()) {
+  if (getAcc()) {
     p << ", " << getAcc();
     p.printOptionalAttrDict((*this)->getAttrs());
   }
   p << " : " << getLhs().getType() << ", " << getRhs().getType();
 }
 
 ParseResult OuterProductOp::parse(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::UnresolvedOperand, 3> operandsInfo;

mlir/lib/Dialect/Vector/Transforms/LowerVectorContract.cpp

LogicalResult matchAndRewrite(vector::OuterProductOp op,
                                 PatternRewriter &rewriter) const override {
     auto loc = op.getLoc();
 
     VectorType lhsType = op.getOperandVectorTypeLHS();
     VectorType rhsType = dyn_cast<VectorType>(op.getOperandTypeRHS());
     VectorType resType = op.getResultVectorType();
     Type eltType = resType.getElementType();
     bool isInt = isa<IntegerType, IndexType>(eltType);
-    Value acc = (op.getAcc().empty()) ? nullptr : op.getAcc()[0];
+    Value acc = op.getAcc();
     vector::CombiningKind kind = op.getKind();
 
     // Vector mask setup.
     OpBuilder::InsertionGuard guard(rewriter);
     auto maskableOp = cast<vector::MaskableOpInterface>(op.getOperation());
     Operation *rootOp;
     Value mask;
     if (maskableOp.isMasked()) {