[flang] Use has_value instead of hasValue (NFC)

[kazu]

Summary

This patch replaces hasValue with has_value in an effort to deprecate
Optional<X>::hasValue.

[clementval]

Thanks. Since we are now down with upstreaming I guess you can send these patches as NFC again. It will not be disturbing for us anymore.

[kazu]

In D129458#3641623, @clementval wrote:

Thanks. Since we are now down with upstreaming I guess you can send these patches as NFC again. It will not be disturbing for us anymore.

Thank you for letting me know!

flang/include/flang/Lower/IterationSpace.h

public:
 
   fir::ArrayLoadOp findBinding(const ArrayBases &base) {
     return loadBindings.lookup(base);
   }
 
   /// `load` must be a LHS array_load. Returns `llvm::None` on error.
   llvm::Optional<size_t> findArgPosition(fir::ArrayLoadOp load);
 
-  bool isLHS(fir::ArrayLoadOp load) { return findArgPosition(load).hasValue(); }
+  bool isLHS(fir::ArrayLoadOp load) {
+    return findArgPosition(load).has_value();
+  }
 
   /// `load` must be a LHS array_load. Determine the threaded inner argument
   /// corresponding to this load.
   mlir::Value findArgumentOfLoad(fir::ArrayLoadOp load) {
     if (auto opt = findArgPosition(load))
       return innerArgs[*opt];
     llvm_unreachable("array load argument not found");
   }
llvm::Optional<fir::ArrayLoadOp> getLhsLoad(size_t i) {
     assert(i < lhsBases.size());
     if (lhsBases[counter])
       return findBinding(lhsBases[counter].getValue());
     return llvm::None;
   }
 
   /// Return the outermost loop in this FORALL nest.
   fir::DoLoopOp getOuterLoop() {
-    assert(outerLoop.hasValue());
+    assert(outerLoop.has_value());
     return outerLoop.getValue();
   }
 
   /// Return the statement context for the entire, outermost FORALL construct.
   StatementContext &outermostContext() { return outerContext; }
 
   /// Generate the explicit loop nest.
   void genLoopNest() {

flang/include/flang/Lower/StatementContext.h

public:
   /// Make cleanup calls.  Clear the stack top list.
   void finalize() {
     finalizeAndKeep();
     cufs.back().reset();
   }
 
   bool workListIsEmpty() const {
     return cufs.empty() || llvm::all_of(cufs, [](auto &opt) -> bool {
-             return !opt.hasValue();
+             return !opt.has_value();
            });
   }
 
 private:
   // A statement context should never be copied or moved.
   StatementContext(const StatementContext &) = delete;
   StatementContext &operator=(const StatementContext &) = delete;
   StatementContext(StatementContext &&) = delete;
 
   // Stack of cleanup function "lists" (nested cleanup function calls).
   llvm::SmallVector<llvm::Optional<CleanupFunction>> cufs;
 };
 
 } // namespace Fortran::lower
 
 #endif // FORTRAN_LOWER_STATEMENTCONTEXT_H

flang/lib/Lower/ConvertExpr.cpp

inline bool isValueAttribute() {
     return semant == ConstituentSemantics::ByValueArg;
   }
 
   /// Can the loops over the expression be unordered?
   inline bool isUnordered() const { return unordered; }
 
   void setUnordered(bool b) { unordered = b; }
 
-  inline bool isPointerAssignment() const { return lbounds.hasValue(); }
+  inline bool isPointerAssignment() const { return lbounds.has_value(); }
 
   inline bool isBoundsSpec() const {
-    return isPointerAssignment() && !ubounds.hasValue();
+    return isPointerAssignment() && !ubounds.has_value();
   }
 
   inline bool isBoundsRemap() const {
-    return isPointerAssignment() && ubounds.hasValue();
+    return isPointerAssignment() && ubounds.has_value();
   }
 
   void setPointerAssignmentBounds(
       const llvm::SmallVector<mlir::Value> &lbs,
       llvm::Optional<llvm::SmallVector<mlir::Value>> ubs) {
     lbounds = lbs;
     ubounds = ubs;
   }

flang/lib/Lower/IterationSpace.cpp

 
 llvm::Optional<size_t>
 Fortran::lower::ExplicitIterSpace::findArgPosition(fir::ArrayLoadOp load) {
   if (lhsBases[counter]) {
     auto ld = loadBindings.find(lhsBases[counter].getValue());
     llvm::Optional<size_t> optPos;
     if (ld != loadBindings.end() && ld->second == load)
       optPos = static_cast<size_t>(0u);
-    assert(optPos.hasValue() && "load does not correspond to lhs");
+    assert(optPos.has_value() && "load does not correspond to lhs");
     return optPos;
   }
   return llvm::None;
 }
 
 llvm::SmallVector<Fortran::lower::FrontEndSymbol>
 Fortran::lower::ExplicitIterSpace::collectAllSymbols() {
   llvm::SmallVector<Fortran::lower::FrontEndSymbol> result;

flang/lib/Optimizer/CodeGen/CodeGen.cpp

matchAndRewrite(fir::GlobalOp global, OpAdaptor adaptor,
     auto tyAttr = convertType(global.getType());
     if (global.getType().isa<fir::BoxType>())
       tyAttr = tyAttr.cast<mlir::LLVM::LLVMPointerType>().getElementType();
     auto loc = global.getLoc();
     mlir::Attribute initAttr;
     if (global.getInitVal())
       initAttr = global.getInitVal().getValue();
     auto linkage = convertLinkage(global.getLinkName());
-    auto isConst = global.getConstant().hasValue();
+    auto isConst = global.getConstant().has_value();
     auto g = rewriter.create<mlir::LLVM::GlobalOp>(
         loc, tyAttr, isConst, linkage, global.getSymName(), initAttr);
     auto &gr = g.getInitializerRegion();
     rewriter.inlineRegionBefore(global.getRegion(), gr, gr.end());
     if (!gr.empty()) {
       // Replace insert_on_range with a constant dense attribute if the
       // initialization is on the full range.
       auto insertOnRangeOps = gr.front().getOps<fir::InsertOnRangeOp>();

flang/lib/Optimizer/Dialect/FIROps.cpp

 //===----------------------------------------------------------------------===//
 
 mlir::FunctionType fir::CallOp::getFunctionType() {
   return mlir::FunctionType::get(getContext(), getOperandTypes(),
                                  getResultTypes());
 }
 
 void fir::CallOp::print(mlir::OpAsmPrinter &p) {
-  bool isDirect = getCallee().hasValue();
+  bool isDirect = getCallee().has_value();
   p << ' ';
   if (isDirect)
     p << getCallee().getValue();
   else
     p << getOperand(0);
   p << '(' << (*this)->getOperands().drop_front(isDirect ? 0 : 1) << ')';
   p.printOptionalAttrDict((*this)->getAttrs(),
                           {fir::CallOp::getCalleeAttrNameStr()});

 
 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.hasValue() && "invalid symbol value for predicate");
+  assert(predSym.has_value() && "invalid symbol value for predicate");
   p << '"' << mlir::arith::stringifyCmpFPredicate(predSym.getValue()) << '"'
     << ", ";
   p.printOperand(op.getLhs());
   p << ", ";
   p.printOperand(op.getRhs());
   p.printOptionalAttrDict(op->getAttrs(),
                           /*elidedAttrs=*/{OPTY::getPredicateAttrName()});
   p << " : " << op.getLhs().getType();
void fir::buildCmpCOp(mlir::OpBuilder &builder, mlir::OperationState &result,
   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.hasValue() && "invalid predicate name");
+  assert(pred.has_value() && "invalid predicate name");
   return pred.getValue();
 }
 
 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);

flang/lib/Optimizer/Transforms/AffinePromotion.cpp

 struct AffineIfCondition {
   using MaybeAffineExpr = llvm::Optional<mlir::AffineExpr>;
 
   explicit AffineIfCondition(mlir::Value fc) : firCondition(fc) {
     if (auto condDef = firCondition.getDefiningOp<mlir::arith::CmpIOp>())
       fromCmpIOp(condDef);
   }
 
-  bool hasIntegerSet() const { return integerSet.hasValue(); }
+  bool hasIntegerSet() const { return integerSet.has_value(); }
 
   mlir::IntegerSet getIntegerSet() const {
     assert(hasIntegerSet() && "integer set is missing");
     return integerSet.getValue();
   }
 
   mlir::ValueRange getAffineArgs() const { return affineArgs; }
 

flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp

 TEST_F(FIRBuilderTest, createGlobal1) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
   auto i64Type = IntegerType::get(builder.getContext(), 64);
   auto global = builder.createGlobal(
       loc, i64Type, "global1", builder.createInternalLinkage(), {}, true);
   EXPECT_TRUE(mlir::isa<fir::GlobalOp>(global));
   EXPECT_EQ("global1", global.getSymName());
-  EXPECT_TRUE(global.getConstant().hasValue());
+  EXPECT_TRUE(global.getConstant().has_value());
   EXPECT_EQ(i64Type, global.getType());
-  EXPECT_TRUE(global.getLinkName().hasValue());
+  EXPECT_TRUE(global.getLinkName().has_value());
   EXPECT_EQ(builder.createInternalLinkage().getValue(),
       global.getLinkName().getValue());
-  EXPECT_FALSE(global.getInitVal().hasValue());
+  EXPECT_FALSE(global.getInitVal().has_value());
 
   auto g1 = builder.getNamedGlobal("global1");
   EXPECT_EQ(global, g1);
   auto g2 = builder.getNamedGlobal("global7");
   EXPECT_EQ(nullptr, g2);
   auto g3 = builder.getNamedGlobal("");
   EXPECT_EQ(nullptr, g3);
 }
 
 TEST_F(FIRBuilderTest, createGlobal2) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
   auto i32Type = IntegerType::get(builder.getContext(), 32);
   auto attr = builder.getIntegerAttr(i32Type, 16);
   auto global = builder.createGlobal(
       loc, i32Type, "global2", builder.createLinkOnceLinkage(), attr, false);
   EXPECT_TRUE(mlir::isa<fir::GlobalOp>(global));
   EXPECT_EQ("global2", global.getSymName());
-  EXPECT_FALSE(global.getConstant().hasValue());
+  EXPECT_FALSE(global.getConstant().has_value());
   EXPECT_EQ(i32Type, global.getType());
-  EXPECT_TRUE(global.getInitVal().hasValue());
+  EXPECT_TRUE(global.getInitVal().has_value());
   EXPECT_TRUE(global.getInitVal().getValue().isa<mlir::IntegerAttr>());
   EXPECT_EQ(
       16, global.getInitVal().getValue().cast<mlir::IntegerAttr>().getValue());
-  EXPECT_TRUE(global.getLinkName().hasValue());
+  EXPECT_TRUE(global.getLinkName().has_value());
   EXPECT_EQ(builder.createLinkOnceLinkage().getValue(),
       global.getLinkName().getValue());
 }
 
 TEST_F(FIRBuilderTest, uniqueCFIdent) {
   auto str1 = fir::factory::uniqueCGIdent("", "func1");
   EXPECT_EQ("_QQ.66756E6331", str1);
   str1 = fir::factory::uniqueCGIdent("", "");
TEST_F(FIRBuilderTest, allocateLocal) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
   llvm::StringRef varName = "var1";
   auto var = builder.allocateLocal(
       loc, builder.getI64Type(), "", varName, {}, {}, false);
   EXPECT_TRUE(mlir::isa<fir::AllocaOp>(var.getDefiningOp()));
   auto allocaOp = dyn_cast<fir::AllocaOp>(var.getDefiningOp());
   EXPECT_EQ(builder.getI64Type(), allocaOp.getInType());
-  EXPECT_TRUE(allocaOp.getBindcName().hasValue());
+  EXPECT_TRUE(allocaOp.getBindcName().has_value());
   EXPECT_EQ(varName, allocaOp.getBindcName().getValue());
-  EXPECT_FALSE(allocaOp.getUniqName().hasValue());
+  EXPECT_FALSE(allocaOp.getUniqName().has_value());
   EXPECT_FALSE(allocaOp.getPinned());
   EXPECT_EQ(0u, allocaOp.getTypeparams().size());
   EXPECT_EQ(0u, allocaOp.getShape().size());
 }
 
 static void checkShapeOp(mlir::Value shape, mlir::Value c10, mlir::Value c100) {
   EXPECT_TRUE(mlir::isa<fir::ShapeOp>(shape.getDefiningOp()));
   fir::ShapeOp op = dyn_cast<fir::ShapeOp>(shape.getDefiningOp());

flang/unittests/Optimizer/Builder/Runtime/RuntimeCallTestBase.h

 /// Check that the \p op is a `fir::CallOp` operation and its name matches
 /// \p fctName and the number of arguments is equal to \p nbArgs.
 /// Most runtime calls have two additional location arguments added. These are
 /// added in this check when \p addLocArgs is true.
 static inline void checkCallOp(mlir::Operation *op, llvm::StringRef fctName,
     unsigned nbArgs, bool addLocArgs = true) {
   EXPECT_TRUE(mlir::isa<fir::CallOp>(*op));
   auto callOp = mlir::dyn_cast<fir::CallOp>(*op);
-  EXPECT_TRUE(callOp.getCallee().hasValue());
+  EXPECT_TRUE(callOp.getCallee().has_value());
   mlir::SymbolRefAttr callee = *callOp.getCallee();
   EXPECT_EQ(fctName, callee.getRootReference().getValue());
   // sourceFile and sourceLine are added arguments.
   if (addLocArgs)
     nbArgs += 2;
   EXPECT_EQ(nbArgs, callOp.getArgs().size());
 }