[flang] Use std::optional instead of llvm::Optional (NFC)

This patch replaces (llvm::|)Optional< with std::optional<.  I'll post
a separate patch to remove #include "llvm/ADT/Optional.h".

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

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

Author: kazutakahirata

flang/include/flang/Lower/BoxAnalyzer.h

@@ -77,7 +77,7 @@ struct ScalarDynamicChar : ScalarSym {
   ScalarDynamicChar(const Fortran::semantics::Symbol &sym)
       : ScalarSym{sym}, len{FromBox{}} {}
 
-  llvm::Optional<Fortran::lower::SomeExpr> charLen() const {
+  std::optional<Fortran::lower::SomeExpr> charLen() const {
     if (auto *l = std::get_if<Fortran::lower::SomeExpr>(&len))
       return {*l};
     return std::nullopt;
@@ -318,17 +318,17 @@ class BoxAnalyzer : public fir::details::matcher<BoxAnalyzer> {
         [](const auto &x) { return x.staticSize(); });
   }
 
-  llvm::Optional<int64_t> getCharLenConst() const {
-    using A = llvm::Optional<int64_t>;
+  std::optional<int64_t> getCharLenConst() const {
+    using A = std::optional<int64_t>;
     return match(
         [](const ScalarStaticChar &x) -> A { return {x.charLen()}; },
         [](const StaticArrayStaticChar &x) -> A { return {x.charLen()}; },
         [](const DynamicArrayStaticChar &x) -> A { return {x.charLen()}; },
         [](const auto &) -> A { return std::nullopt; });
   }
 
-  llvm::Optional<Fortran::lower::SomeExpr> getCharLenExpr() const {
-    using A = llvm::Optional<Fortran::lower::SomeExpr>;
+  std::optional<Fortran::lower::SomeExpr> getCharLenExpr() const {
+    using A = std::optional<Fortran::lower::SomeExpr>;
     return match([](const ScalarDynamicChar &x) { return x.charLen(); },
                  [](const StaticArrayDynamicChar &x) { return x.charLen(); },
                  [](const DynamicArrayDynamicChar &x) { return x.charLen(); },
@@ -472,9 +472,9 @@ class BoxAnalyzer : public fir::details::matcher<BoxAnalyzer> {
   }
 
   // Get the constant LEN of a CHARACTER, if it exists.
-  llvm::Optional<int64_t>
+  std::optional<int64_t>
   charLenConstant(const Fortran::semantics::Symbol &sym) {
-    if (llvm::Optional<Fortran::lower::SomeExpr> expr = charLenVariable(sym))
+    if (std::optional<Fortran::lower::SomeExpr> expr = charLenVariable(sym))
       if (std::optional<int64_t> asInt = Fortran::evaluate::ToInt64(*expr)) {
         // Length is max(0, *asInt) (F2018 7.4.4.2 point 5.).
         if (*asInt < 0)
@@ -485,7 +485,7 @@ class BoxAnalyzer : public fir::details::matcher<BoxAnalyzer> {
   }
 
   // Get the `SomeExpr` that describes the CHARACTER's LEN.
-  llvm::Optional<Fortran::lower::SomeExpr>
+  std::optional<Fortran::lower::SomeExpr>
   charLenVariable(const Fortran::semantics::Symbol &sym) {
     const Fortran::semantics::ParamValue &lenParam =
         sym.GetType()->characterTypeSpec().length();

flang/include/flang/Lower/ComponentPath.h

@@ -69,7 +69,7 @@ class ComponentPath {
   /// This optional continuation allows the generation of those dereferences.
   /// These accesses are always on Fortran entities of record types, which are
   /// implicitly in-memory objects.
-  llvm::Optional<ExtendRefFunc> extendCoorRef = std::nullopt;
+  std::optional<ExtendRefFunc> extendCoorRef = std::nullopt;
 
 private:
   void setPC(bool isImplicit);

flang/include/flang/Lower/ConvertCall.h

@@ -32,7 +32,7 @@ fir::ExtendedValue genCallOpAndResult(
     mlir::Location loc, Fortran::lower::AbstractConverter &converter,
     Fortran::lower::SymMap &symMap, Fortran::lower::StatementContext &stmtCtx,
     Fortran::lower::CallerInterface &caller, mlir::FunctionType callSiteType,
-    llvm::Optional<mlir::Type> resultType);
+    std::optional<mlir::Type> resultType);
 
 /// If \p arg is the address of a function with a denoted host-association tuple
 /// argument, then return the host-associations tuple value of the current
@@ -42,11 +42,10 @@ mlir::Value argumentHostAssocs(Fortran::lower::AbstractConverter &converter,
 
 /// Lower a ProcedureRef to HLFIR. If this is a function call, return the
 /// lowered result value. Return nothing otherwise.
-llvm::Optional<hlfir::EntityWithAttributes> convertCallToHLFIR(
+std::optional<hlfir::EntityWithAttributes> convertCallToHLFIR(
     mlir::Location loc, Fortran::lower::AbstractConverter &converter,
-    const evaluate::ProcedureRef &procRef,
-    llvm::Optional<mlir::Type> resultType, Fortran::lower::SymMap &symMap,
-    Fortran::lower::StatementContext &stmtCtx);
+    const evaluate::ProcedureRef &procRef, std::optional<mlir::Type> resultType,
+    Fortran::lower::SymMap &symMap, Fortran::lower::StatementContext &stmtCtx);
 
 } // namespace Fortran::lower
 #endif // FORTRAN_LOWER_CONVERTCALL_H

flang/include/flang/Lower/ConvertExpr.h

@@ -176,7 +176,7 @@ void createArrayOfPointerAssignment(
     AbstractConverter &converter, const SomeExpr &lhs, const SomeExpr &rhs,
     ExplicitIterSpace &explicitIterSpace, ImplicitIterSpace &implicitIterSpace,
     const llvm::SmallVector<mlir::Value> &lbounds,
-    llvm::Optional<llvm::SmallVector<mlir::Value>> ubounds, SymMap &symMap,
+    std::optional<llvm::SmallVector<mlir::Value>> ubounds, SymMap &symMap,
     StatementContext &stmtCtx);
 
 /// Lower an array expression with "parallel" semantics. Such a rhs expression

flang/include/flang/Lower/CustomIntrinsicCall.h

@@ -54,7 +54,7 @@ using OperandPrepare = std::function<void(const Fortran::lower::SomeExpr &)>;
 /// preparation was done. An absent optional means the argument is statically
 /// present. An mlir::Value means the presence must be checked at runtime, and
 /// that the value contains the "is present" boolean value.
-using OperandPresent = std::function<llvm::Optional<mlir::Value>(std::size_t)>;
+using OperandPresent = std::function<std::optional<mlir::Value>(std::size_t)>;
 
 /// Type of the callback to generate an argument reference after the call
 /// preparation was done. For optional arguments, the utility guarantees
@@ -77,7 +77,7 @@ using OperandGetter = std::function<fir::ExtendedValue(std::size_t)>;
 void prepareCustomIntrinsicArgument(
     const Fortran::evaluate::ProcedureRef &procRef,
     const Fortran::evaluate::SpecificIntrinsic &intrinsic,
-    llvm::Optional<mlir::Type> retTy,
+    std::optional<mlir::Type> retTy,
     const OperandPrepare &prepareOptionalArgument,
     const OperandPrepare &prepareOtherArgument, AbstractConverter &converter);
 
@@ -90,7 +90,7 @@ void prepareCustomIntrinsicArgument(
 /// not generate any implicit loop nest on its own).
 fir::ExtendedValue
 lowerCustomIntrinsic(fir::FirOpBuilder &builder, mlir::Location loc,
-                     llvm::StringRef name, llvm::Optional<mlir::Type> retTy,
+                     llvm::StringRef name, std::optional<mlir::Type> retTy,
                      const OperandPresent &isPresentCheck,
                      const OperandGetter &getOperand, std::size_t numOperands,
                      Fortran::lower::StatementContext &stmtCtx);

flang/include/flang/Lower/IntrinsicCall.h

@@ -29,7 +29,7 @@ class StatementContext;
 /// Returned mlir::Value is the returned Fortran intrinsic value.
 fir::ExtendedValue genIntrinsicCall(fir::FirOpBuilder &, mlir::Location,
                                     llvm::StringRef name,
-                                    llvm::Optional<mlir::Type> resultType,
+                                    std::optional<mlir::Type> resultType,
                                     llvm::ArrayRef<fir::ExtendedValue> args,
                                     StatementContext &);
 

flang/include/flang/Lower/IterationSpace.h

@@ -445,7 +445,7 @@ class ExplicitIterSpace {
   }
 
   /// `load` must be a LHS array_load. Returns `std::nullopt` on error.
-  llvm::Optional<size_t> findArgPosition(fir::ArrayLoadOp load);
+  std::optional<size_t> findArgPosition(fir::ArrayLoadOp load);
 
   bool isLHS(fir::ArrayLoadOp load) {
     return findArgPosition(load).has_value();
@@ -466,7 +466,7 @@ class ExplicitIterSpace {
     llvm_unreachable("inner argument value was not found");
   }
 
-  llvm::Optional<fir::ArrayLoadOp> getLhsLoad(size_t i) {
+  std::optional<fir::ArrayLoadOp> getLhsLoad(size_t i) {
     assert(i < lhsBases.size());
     if (lhsBases[counter])
       return findBinding(*lhsBases[counter]);
@@ -542,7 +542,7 @@ class ExplicitIterSpace {
 
   // A stack of lists of front-end symbols.
   llvm::SmallVector<llvm::SmallVector<FrontEndSymbol>> symbolStack;
-  llvm::SmallVector<llvm::Optional<ArrayBases>> lhsBases;
+  llvm::SmallVector<std::optional<ArrayBases>> lhsBases;
   llvm::SmallVector<llvm::SmallVector<ArrayBases>> rhsBases;
   llvm::DenseMap<ArrayBases, fir::ArrayLoadOp> loadBindings;
 
@@ -553,9 +553,9 @@ class ExplicitIterSpace {
   StatementContext stmtCtx;
   llvm::SmallVector<mlir::Value> innerArgs;
   llvm::SmallVector<mlir::Value> initialArgs;
-  llvm::Optional<fir::DoLoopOp> outerLoop;
+  std::optional<fir::DoLoopOp> outerLoop;
   llvm::SmallVector<llvm::SmallVector<fir::DoLoopOp>> loopStack;
-  llvm::Optional<std::function<void(fir::FirOpBuilder &)>> loopCleanup;
+  std::optional<std::function<void(fir::FirOpBuilder &)>> loopCleanup;
   std::size_t forallContextOpen = 0;
   std::size_t counter = 0;
 };

flang/include/flang/Lower/Runtime.h

@@ -78,9 +78,9 @@ void genPointerAssociateRemapping(fir::FirOpBuilder &, mlir::Location,
 
 mlir::Value genCpuTime(fir::FirOpBuilder &, mlir::Location);
 void genDateAndTime(fir::FirOpBuilder &, mlir::Location,
-                    llvm::Optional<fir::CharBoxValue> date,
-                    llvm::Optional<fir::CharBoxValue> time,
-                    llvm::Optional<fir::CharBoxValue> zone, mlir::Value values);
+                    std::optional<fir::CharBoxValue> date,
+                    std::optional<fir::CharBoxValue> time,
+                    std::optional<fir::CharBoxValue> zone, mlir::Value values);
 
 void genRandomInit(fir::FirOpBuilder &, mlir::Location, mlir::Value repeatable,
                    mlir::Value imageDistinct);

flang/include/flang/Lower/SymbolMap.h

@@ -349,7 +349,7 @@ class SymMap {
     symbolMapStack.back().try_emplace(sym, definingOp);
   }
 
-  llvm::Optional<fir::FortranVariableOpInterface>
+  std::optional<fir::FortranVariableOpInterface>
   lookupVariableDefinition(semantics::SymbolRef sym);
 
 private:

flang/include/flang/Optimizer/Builder/FIRBuilder.h

@@ -596,8 +596,8 @@ mlir::Value createZeroValue(fir::FirOpBuilder &builder, mlir::Location loc,
                             mlir::Type type);
 
 /// Get the integer constants of triplet and compute the extent.
-llvm::Optional<std::int64_t>
-getExtentFromTriplet(mlir::Value lb, mlir::Value ub, mlir::Value stride);
+std::optional<std::int64_t> getExtentFromTriplet(mlir::Value lb, mlir::Value ub,
+                                                 mlir::Value stride);
 
 /// Generate max(\p value, 0) where \p value is a scalar integer.
 mlir::Value genMaxWithZero(fir::FirOpBuilder &builder, mlir::Location loc,