mlir/linalg: use std::optional

[artagnon]

Summary

This is part of an effort to migrate from llvm::Optional to std::optional:

See also: https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716

Signed-off-by: Ramkumar Ramachandra <[e-mail]>

[kazu]

Thanks a lot for helping with the migration!

[artagnon]

Hi. Ever since the migration to the git monorepo (I know, it's been a while), I don't have commit access. Could you kindly commit this and D138765 for me? Thanks.

[kazu]

In D138767#3952312, @artagnon wrote:

Hi. Ever since the migration to the git monorepo (I know, it's been a while), I don't have commit access. Could you kindly commit this and D138765 for me? Thanks.

Done.

[artagnon]

Committed as 537137ece1d.

mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp

 /// an operand/result with the unit-extent dimension removed. This is only done
 /// if the indexing map used to access that dimension has a
 /// AffineConstantExpr of value 0. Given the `type` of an result/operand of a
 /// Linalg op, and its `indexMap` the utility function returns:
 /// - the new type with dimensions of size 1 removed.
 /// - modified index map that can be used to access the replaced result/operand
 /// - the reassociation that converts from the original tensor type to the
 ///   modified tensor type.
-static llvm::Optional<UnitExtentReplacementInfo>
+static std::optional<UnitExtentReplacementInfo>
 replaceUnitExtents(GenericOp genericOp, OpOperand *opOperand,
                    MLIRContext *context) {
   AffineMap indexingMap = genericOp.getMatchingIndexingMap(opOperand);
   ArrayRef<int64_t> shape = genericOp.getShape(opOperand);
   ArrayRef<AffineExpr> exprs = indexingMap.getResults();
   SmallVector<AffineExpr> reassociations;
   SmallVector<Attribute> reassociationMaps;
   SmallVector<AffineExpr> newIndexExprs;

mlir/lib/Dialect/Linalg/Transforms/Hoisting.cpp

 struct HoistableRead {
   vector::TransferReadOp transferReadOp;
   tensor::ExtractSliceOp extractSliceOp;
 };
 } // namespace
 
 /// Return true if op1 and op2 are the same constant or the same SSA value.
 static bool isEqualOffsetSizeOrStride(OpFoldResult op1, OpFoldResult op2) {
-  auto getConstantIntValue = [](OpFoldResult ofr) -> llvm::Optional<int64_t> {
+  auto getConstantIntValue = [](OpFoldResult ofr) -> std::optional<int64_t> {
     Attribute attr = ofr.dyn_cast<Attribute>();
     // Note: isa+cast-like pattern allows writing the condition below as 1 line.
     if (!attr && ofr.get<Value>().getDefiningOp<arith::ConstantOp>())
       attr = ofr.get<Value>().getDefiningOp<arith::ConstantOp>().getValue();
     if (auto intAttr = attr.dyn_cast_or_null<IntegerAttr>())
       return intAttr.getValue().getSExtValue();
-    return llvm::None;
+    return std::nullopt;
   };
   auto cst1 = getConstantIntValue(op1), cst2 = getConstantIntValue(op2);
   if (cst1 && cst2 && *cst1 == *cst2)
     return true;
   auto v1 = op1.dyn_cast<Value>(), v2 = op2.dyn_cast<Value>();
   return v1 && v2 && v1 == v2;
 }