[flang] Use value instead of getValue (NFC)

[kazu]

Summary

Flang C++ Style Guide tells us to use x.value() when no presence test
is obviously protecting the reference. Since assert can be disabled,
I don't count it as "protection" here.

[clementval]

LGTM

flang/include/flang/Lower/IterationSpace.h

llvm::Optional<fir::ArrayLoadOp> getLhsLoad(size_t i) {
     if (lhsBases[counter])
       return findBinding(*lhsBases[counter]);
     return llvm::None;
   }
 
   /// Return the outermost loop in this FORALL nest.
   fir::DoLoopOp getOuterLoop() {
     assert(outerLoop.has_value());
-    return outerLoop.getValue();
+    return outerLoop.value();
   }
 
   /// Return the statement context for the entire, outermost FORALL construct.
   StatementContext &outermostContext() { return outerContext; }
 
   /// Generate the explicit loop nest.
   void genLoopNest() {
     for (auto &lambda : ccLoopNest)

flang/lib/Lower/CustomIntrinsicCall.cpp

lowerIshftc(fir::FirOpBuilder &builder, mlir::Location loc,
             const Fortran::lower::OperandPresent &isPresentCheck,
             const Fortran::lower::OperandGetter &getOperand,
             std::size_t numOperands,
             Fortran::lower::StatementContext &stmtCtx) {
   assert(numOperands == 3 && !isPresentCheck(0) && !isPresentCheck(1) &&
          isPresentCheck(2) &&
          "only ISHFTC SIZE arg is expected to be dynamically optional here");
   assert(retTy && "ISFHTC must have a return type");
-  mlir::Type resultType = retTy.getValue();
+  mlir::Type resultType = retTy.value();
   llvm::SmallVector<fir::ExtendedValue> args;
   args.push_back(getOperand(0));
   args.push_back(getOperand(1));
   args.push_back(builder
-                     .genIfOp(loc, {resultType}, isPresentCheck(2).getValue(),
+                     .genIfOp(loc, {resultType}, isPresentCheck(2).value(),
                               /*withElseRegion=*/true)
                      .genThen([&]() {
                        fir::ExtendedValue sizeExv = getOperand(2);
                        mlir::Value size = builder.createConvert(
                            loc, resultType, fir::getBase(sizeExv));
                        builder.create<fir::ResultOp>(loc, size);
                      })
                      .genElse([&]() {

flang/lib/Optimizer/Dialect/FIROps.cpp

 template <typename OPTY>
 static void printCmpOp(mlir::OpAsmPrinter &p, OPTY op) {
   p << ' ';
   auto predSym = mlir::arith::symbolizeCmpFPredicate(
       op->template getAttrOfType<mlir::IntegerAttr>(
             OPTY::getPredicateAttrName())
           .getInt());
   assert(predSym.has_value() && "invalid symbol value for predicate");
-  p << '"' << mlir::arith::stringifyCmpFPredicate(predSym.getValue()) << '"'
+  p << '"' << mlir::arith::stringifyCmpFPredicate(predSym.value()) << '"'
     << ", ";
   p.printOperand(op.getLhs());
   p << ", ";
   p.printOperand(op.getRhs());
   p.printOptionalAttrDict(op->getAttrs(),
                           /*elidedAttrs=*/{OPTY::getPredicateAttrName()});
   p << " : " << op.getLhs().getType();
 }
result.addAttribute(
       fir::CmpcOp::getPredicateAttrName(),
       builder.getI64IntegerAttr(static_cast<std::int64_t>(predicate)));
 }
 
 mlir::arith::CmpFPredicate
 fir::CmpcOp::getPredicateByName(llvm::StringRef name) {
   auto pred = mlir::arith::symbolizeCmpFPredicate(name);
   assert(pred.has_value() && "invalid predicate name");
-  return pred.getValue();
+  return pred.value();
 }
 
 void fir::CmpcOp::print(mlir::OpAsmPrinter &p) { printCmpOp(p, *this); }
 
 mlir::ParseResult fir::CmpcOp::parse(mlir::OpAsmParser &parser,
                                      mlir::OperationState &result) {
   return parseCmpOp<fir::CmpcOp>(parser, result);
 }