[flang][NFC] rename isAbsent to isStaticallyAbsent in IntrinsicCall.cpp

[jeanPerier]

Summary

isAbsent/isPresent helpers only give information about static presence
of intrinsic arguments. Many intrinsic arguments optionality is dynamic
(an absent dummy can legally be passed to these intrinsics). This
requires a different handling (like handleDynamicOptional).

Rename the helpers to avoid misleading coder/reader into thinking all
optionality cases are covered by them.

[clementval]

LGTM

flang/lib/Lower/IntrinsicCall.cpp

enum class ExtremumBehavior {
   // LLVM/MLIR do not provide ways to observe this aspect, so it is not
   // possible to implement it without some target dependent runtime.
 };
 
 fir::ExtendedValue Fortran::lower::getAbsentIntrinsicArgument() {
   return fir::UnboxedValue{};
 }
 
-/// Test if an ExtendedValue is absent.
-static bool isAbsent(const fir::ExtendedValue &exv) {
+/// Test if an ExtendedValue is absent. This is used to test if an intrinsic
+/// argument are absent at compile time.
+static bool isStaticallyAbsent(const fir::ExtendedValue &exv) {
   return !fir::getBase(exv);
 }
-static bool isAbsent(llvm::ArrayRef<fir::ExtendedValue> args, size_t argIndex) {
-  return args.size() <= argIndex || isAbsent(args[argIndex]);
+static bool isStaticallyAbsent(llvm::ArrayRef<fir::ExtendedValue> args,
+                               size_t argIndex) {
+  return args.size() <= argIndex || isStaticallyAbsent(args[argIndex]);
 }
-static bool isAbsent(llvm::ArrayRef<mlir::Value> args, size_t argIndex) {
+static bool isStaticallyAbsent(llvm::ArrayRef<mlir::Value> args,
+                               size_t argIndex) {
   return args.size() <= argIndex || !args[argIndex];
 }
 
-/// Test if an ExtendedValue is present.
-static bool isPresent(const fir::ExtendedValue &exv) { return !isAbsent(exv); }
+/// Test if an ExtendedValue is present. This is used to test if an intrinsic
+/// argument is present at compile time. This does not imply that the related
+/// value may not be an absent dummy optional, disassociated pointer, or a
+/// deallocated allocatable. See `handleDynamicOptional` to deal with these
+/// cases when it makes sense.
+static bool isStaticallyPresent(const fir::ExtendedValue &exv) {
+  return !isStaticallyAbsent(exv);
+}
 
 /// Process calls to Maxval, Minval, Product, Sum intrinsic functions that
 /// take a DIM argument.
 template <typename FD>
 static fir::ExtendedValue
 genFuncDim(FD funcDim, mlir::Type resultType, fir::FirOpBuilder &builder,
            mlir::Location loc, Fortran::lower::StatementContext *stmtCtx,
            llvm::StringRef errMsg, mlir::Value array, fir::ExtendedValue dimArg,
            mlir::Value mask, int rank) {
 
   // Create mutable fir.box to be passed to the runtime for the result.
   mlir::Type resultArrayType = builder.getVarLenSeqTy(resultType, rank - 1);
   fir::MutableBoxValue resultMutableBox =
       fir::factory::createTempMutableBox(builder, loc, resultArrayType);
   mlir::Value resultIrBox =
       fir::factory::getMutableIRBox(builder, loc, resultMutableBox);
 
   mlir::Value dim =
-      isAbsent(dimArg)
+      isStaticallyAbsent(dimArg)
           ? builder.createIntegerConstant(loc, builder.getIndexType(), 0)
           : fir::getBase(dimArg);
   funcDim(builder, loc, resultIrBox, array, dim, mask);
 
   fir::ExtendedValue res =
       fir::factory::genMutableBoxRead(builder, loc, resultMutableBox);
   return res.match(
       [&](const fir::ArrayBoxValue &box) -> fir::ExtendedValue {
genProdOrSum(FN func, FD funcDim, mlir::Type resultType,
 
   // Handle required array argument
   fir::BoxValue arryTmp = builder.createBox(loc, args[0]);
   mlir::Value array = fir::getBase(arryTmp);
   int rank = arryTmp.rank();
   assert(rank >= 1);
 
   // Handle optional mask argument
-  auto mask = isAbsent(args[2])
+  auto mask = isStaticallyAbsent(args[2])
                   ? builder.create<fir::AbsentOp>(
                         loc, fir::BoxType::get(builder.getI1Type()))
                   : builder.createBox(loc, args[2]);
 
-  bool absentDim = isAbsent(args[1]);
+  bool absentDim = isStaticallyAbsent(args[1]);
 
   // We call the type specific versions because the result is scalar
   // in the case below.
   if (absentDim || rank == 1) {
     mlir::Type ty = array.getType();
     mlir::Type arrTy = fir::dyn_cast_ptrOrBoxEleTy(ty);
     auto eleTy = arrTy.cast<fir::SequenceType>().getEleTy();
     if (fir::isa_complex(eleTy)) {
genExtremumVal(FN func, FD funcDim, FC funcChar, mlir::Type resultType,
   // Handle required array argument
   fir::BoxValue arryTmp = builder.createBox(loc, args[0]);
   mlir::Value array = fir::getBase(arryTmp);
   int rank = arryTmp.rank();
   assert(rank >= 1);
   bool hasCharacterResult = arryTmp.isCharacter();
 
   // Handle optional mask argument
-  auto mask = isAbsent(args[2])
+  auto mask = isStaticallyAbsent(args[2])
                   ? builder.create<fir::AbsentOp>(
                         loc, fir::BoxType::get(builder.getI1Type()))
                   : builder.createBox(loc, args[2]);
 
-  bool absentDim = isAbsent(args[1]);
+  bool absentDim = isStaticallyAbsent(args[1]);
 
   // For Maxval/MinVal, we call the type specific versions of
   // Maxval/Minval because the result is scalar in the case below.
   if (!hasCharacterResult && (absentDim || rank == 1))
     return func(builder, loc, array, mask);
 
   if (hasCharacterResult && (absentDim || rank == 1)) {
     // Create mutable fir.box to be passed to the runtime for the result.
static fir::ExtendedValue genExtremumloc(
   assert(args.size() == 5);
 
   // Handle required array argument
   mlir::Value array = builder.createBox(loc, args[0]);
   unsigned rank = fir::BoxValue(array).rank();
   assert(rank >= 1);
 
   // Handle optional mask argument
-  auto mask = isAbsent(args[2])
+  auto mask = isStaticallyAbsent(args[2])
                   ? builder.create<fir::AbsentOp>(
                         loc, fir::BoxType::get(builder.getI1Type()))
                   : builder.createBox(loc, args[2]);
 
   // Handle optional kind argument
-  auto kind = isAbsent(args[3]) ? builder.createIntegerConstant(
-                                      loc, builder.getIndexType(),
-                                      builder.getKindMap().defaultIntegerKind())
-                                : fir::getBase(args[3]);
+  auto kind = isStaticallyAbsent(args[3])
+                  ? builder.createIntegerConstant(
 
   // Handle optional back argument
-  auto back = isAbsent(args[4]) ? builder.createBool(loc, false)
+  auto back = isStaticallyAbsent(args[4]) ? builder.createBool(loc, false)
                                           : fir::getBase(args[4]);
 
-  bool absentDim = isAbsent(args[1]);
+  bool absentDim = isStaticallyAbsent(args[1]);
 
   if (!absentDim && rank == 1) {
     // If dim argument is present and the array is rank 1, then the result is
     // a scalar (since the the result is rank-1 or 0).
     // Therefore, we use a scalar result descriptor with Min/MaxlocDim().
     mlir::Value dim = fir::getBase(args[1]);
     // Create mutable fir.box to be passed to the runtime for the result.
     fir::MutableBoxValue resultMutableBox =
IntrinsicLibrary::genAll(mlir::Type resultType,
   // Handle required mask argument
   mlir::Value mask = builder.createBox(loc, args[0]);
 
   fir::BoxValue maskArry = builder.createBox(loc, args[0]);
   int rank = maskArry.rank();
   assert(rank >= 1);
 
   // Handle optional dim argument
-  bool absentDim = isAbsent(args[1]);
+  bool absentDim = isStaticallyAbsent(args[1]);
   mlir::Value dim =
       absentDim ? builder.createIntegerConstant(loc, builder.getIndexType(), 1)
                 : fir::getBase(args[1]);
 
   if (rank == 1 || absentDim)
     return builder.createConvert(loc, resultType,
                                  fir::runtime::genAll(builder, loc, mask, dim));
 
IntrinsicLibrary::genAny(mlir::Type resultType,
   // Handle required mask argument
   mlir::Value mask = builder.createBox(loc, args[0]);
 
   fir::BoxValue maskArry = builder.createBox(loc, args[0]);
   int rank = maskArry.rank();
   assert(rank >= 1);
 
   // Handle optional dim argument
-  bool absentDim = isAbsent(args[1]);
+  bool absentDim = isStaticallyAbsent(args[1]);
   mlir::Value dim =
       absentDim ? builder.createIntegerConstant(loc, builder.getIndexType(), 1)
                 : fir::getBase(args[1]);
 
   if (rank == 1 || absentDim)
     return builder.createConvert(loc, resultType,
                                  fir::runtime::genAny(builder, loc, mask, dim));
 
IntrinsicLibrary::genAssociated(mlir::Type resultType,
                                 llvm::ArrayRef<fir::ExtendedValue> args) {
   assert(args.size() == 2);
   auto *pointer =
       args[0].match([&](const fir::MutableBoxValue &x) { return &x; },
                     [&](const auto &) -> const fir::MutableBoxValue * {
                       fir::emitFatalError(loc, "pointer not a MutableBoxValue");
                     });
   const fir::ExtendedValue &target = args[1];
-  if (isAbsent(target))
+  if (isStaticallyAbsent(target))
     return fir::factory::genIsAllocatedOrAssociatedTest(builder, loc, *pointer);
 
   mlir::Value targetBox = builder.createBox(loc, target);
   if (fir::valueHasFirAttribute(fir::getBase(target),
                                 fir::getOptionalAttrName())) {
     // Subtle: contrary to other intrinsic optional arguments, disassociated
     // POINTER and unallocated ALLOCATABLE actual argument are not considered
     // absent here. This is because ASSOCIATED has special requirements for

 
 // CMPLX
 mlir::Value IntrinsicLibrary::genCmplx(mlir::Type resultType,
                                        llvm::ArrayRef<mlir::Value> args) {
   assert(args.size() >= 1);
   fir::factory::Complex complexHelper(builder, loc);
   mlir::Type partType = complexHelper.getComplexPartType(resultType);
   mlir::Value real = builder.createConvert(loc, partType, args[0]);
-  mlir::Value imag = isAbsent(args, 1)
+  mlir::Value imag = isStaticallyAbsent(args, 1)
                          ? builder.createRealZeroConstant(loc, partType)
                          : builder.createConvert(loc, partType, args[1]);
   return fir::factory::Complex{builder, loc}.createComplex(resultType, real,
                                                            imag);
 }
 
 // COMMAND_ARGUMENT_COUNT
 fir::ExtendedValue IntrinsicLibrary::genCommandArgumentCount(
IntrinsicLibrary::genCount(mlir::Type resultType,
 
   // Handle mask argument
   fir::BoxValue mask = builder.createBox(loc, args[0]);
   unsigned maskRank = mask.rank();
 
   assert(maskRank > 0);
 
   // Handle optional dim argument
-  bool absentDim = isAbsent(args[1]);
+  bool absentDim = isStaticallyAbsent(args[1]);
   mlir::Value dim =
       absentDim ? builder.createIntegerConstant(loc, builder.getIndexType(), 0)
                 : fir::getBase(args[1]);
 
   if (absentDim || maskRank == 1) {
     // Result is scalar if no dim argument or mask is rank 1.
     // So, call specialized Count runtime routine.
     return builder.createConvert(
         loc, resultType,
         fir::runtime::genCount(builder, loc, fir::getBase(mask), dim));
   }
 
   // Call general CountDim runtime routine.
 
   // Handle optional kind argument
-  bool absentKind = isAbsent(args[2]);
+  bool absentKind = isStaticallyAbsent(args[2]);
   mlir::Value kind = absentKind ? builder.createIntegerConstant(
                                       loc, builder.getIndexType(),
                                       builder.getKindMap().defaultIntegerKind())
                                 : fir::getBase(args[2]);
 
   // Create mutable fir.box to be passed to the runtime for the result.
   mlir::Type type = builder.getVarLenSeqTy(resultType, maskRank - 1);
   fir::MutableBoxValue resultMutableBox =
if (arrayRank == 1) {
     fir::runtime::genCshiftVector(builder, loc, resultIrBox, array, shift);
   } else {
     // Non-vector case
     // Handle required SHIFT argument as an array
     mlir::Value shift = builder.createBox(loc, args[1]);
 
     // Handle optional DIM argument
     mlir::Value dim =
-        isAbsent(args[2])
+        isStaticallyAbsent(args[2])
             ? builder.createIntegerConstant(loc, builder.getIndexType(), 1)
             : fir::getBase(args[2]);
     fir::runtime::genCshift(builder, loc, resultIrBox, array, shift, dim);
   }
   return readAndAddCleanUp(resultMutableBox, resultType, "CSHIFT");
 }
 
 // DATE_AND_TIME
IntrinsicLibrary::genEoshift(mlir::Type resultType,
   mlir::Type resultArrayType = builder.getVarLenSeqTy(resultType, arrayRank);
   fir::MutableBoxValue resultMutableBox =
       fir::factory::createTempMutableBox(builder, loc, resultArrayType);
   mlir::Value resultIrBox =
       fir::factory::getMutableIRBox(builder, loc, resultMutableBox);
 
   // Handle optional BOUNDARY argument
   mlir::Value boundary =
-      isAbsent(args[2]) ? builder.create<fir::AbsentOp>(
-                              loc, fir::BoxType::get(builder.getNoneType()))
-                        : builder.createBox(loc, args[2]);
+      isStaticallyAbsent(args[2])
+          ? builder.create<fir::AbsentOp>(
 
   if (arrayRank == 1) {
     // Vector case
     // Handle required SHIFT argument as a scalar
     const mlir::Value *shiftAddr = args[1].getUnboxed();
     assert(shiftAddr && "nonscalar EOSHIFT SHIFT argument");
     auto shift = builder.create<fir::LoadOp>(loc, *shiftAddr);
     fir::runtime::genEoshiftVector(builder, loc, resultIrBox, array, shift,
                                    boundary);
   } else {
     // Non-vector case
     // Handle required SHIFT argument as an array
     mlir::Value shift = builder.createBox(loc, args[1]);
 
     // Handle optional DIM argument
     mlir::Value dim =
-        isAbsent(args[3])
+        isStaticallyAbsent(args[3])
             ? builder.createIntegerConstant(loc, builder.getIndexType(), 1)
             : fir::getBase(args[3]);
     fir::runtime::genEoshift(builder, loc, resultIrBox, array, shift, boundary,
                              dim);
   }
   return readAndAddCleanUp(resultMutableBox, resultType,
                            "unexpected result for EOSHIFT");
 }
 
 // EXIT
 void IntrinsicLibrary::genExit(llvm::ArrayRef<fir::ExtendedValue> args) {
   assert(args.size() == 1);
 
   mlir::Value status =
-      isAbsent(args[0])
+      isStaticallyAbsent(args[0])
           ? builder.createIntegerConstant(loc, builder.getDefaultIntegerType(),
                                           EXIT_SUCCESS)
           : fir::getBase(args[0]);
 
   assert(status.getType() == builder.getDefaultIntegerType() &&
          "STATUS parameter must be an INTEGER of default kind");
 
   fir::runtime::genExit(builder, loc, status);
void IntrinsicLibrary::genGetEnvironmentVariable(
 
   // Handle optional LENGTH argument
   mlir::Value length = fir::getBase(args[2]);
 
   // Handle optional STATUS argument
   mlir::Value status = fir::getBase(args[3]);
 
   // Handle optional TRIM_NAME argument
-  mlir::Value trim_name =
-      isAbsent(args[4]) ? builder.createBool(loc, true) : fir::getBase(args[4]);
+  mlir::Value trim_name = isStaticallyAbsent(args[4])
+                              ? builder.createBool(loc, true)
+                              : fir::getBase(args[4]);
 
   // Handle optional ERRMSG argument
   mlir::Value errmsg;
   llvm::Optional<fir::CharBoxValue> errmsgBox;
   if (const fir::CharBoxValue *charBox = args[5].getCharBox())
     errmsgBox = *charBox;
   processCharBox(errmsgBox, errmsg);
 
IntrinsicLibrary::genIndex(mlir::Type resultType,
   mlir::Value stringBase = fir::getBase(args[0]);
   fir::KindTy kind =
       fir::factory::CharacterExprHelper{builder, loc}.getCharacterKind(
           stringBase.getType());
   mlir::Value stringLen = fir::getLen(args[0]);
   mlir::Value substringBase = fir::getBase(args[1]);
   mlir::Value substringLen = fir::getLen(args[1]);
   mlir::Value back =
-      isAbsent(args, 2)
+      isStaticallyAbsent(args, 2)
           ? builder.createIntegerConstant(loc, builder.getI1Type(), 0)
           : fir::getBase(args[2]);
-  if (isAbsent(args, 3))
+  if (isStaticallyAbsent(args, 3))
     return builder.createConvert(
         loc, resultType,
         fir::runtime::genIndex(builder, loc, kind, stringBase, stringLen,
                                substringBase, substringLen, back));
 
   // Call the descriptor-based Index implementation
   mlir::Value string = builder.createBox(loc, args[0]);
   mlir::Value substring = builder.createBox(loc, args[1]);
   auto makeRefThenEmbox = [&](mlir::Value b) {
     fir::LogicalType logTy = fir::LogicalType::get(
         builder.getContext(), builder.getKindMap().defaultLogicalKind());
     mlir::Value temp = builder.createTemporary(loc, logTy);
     mlir::Value castb = builder.createConvert(loc, logTy, b);
     builder.create<fir::StoreOp>(loc, castb, temp);
     return builder.createBox(loc, temp);
   };
-  mlir::Value backOpt = isAbsent(args, 2)
+  mlir::Value backOpt = isStaticallyAbsent(args, 2)
                             ? builder.create<fir::AbsentOp>(
                                   loc, fir::BoxType::get(builder.getI1Type()))
                             : makeRefThenEmbox(fir::getBase(args[2]));
-  mlir::Value kindVal = isAbsent(args, 3)
+  mlir::Value kindVal = isStaticallyAbsent(args, 3)
                             ? builder.createIntegerConstant(
                                   loc, builder.getIndexType(),
                                   builder.getKindMap().defaultIntegerKind())
                             : fir::getBase(args[3]);
   // Create mutable fir.box to be passed to the runtime for the result.
   fir::MutableBoxValue mutBox =
       fir::factory::createTempMutableBox(builder, loc, resultType);
   mlir::Value resBox = fir::factory::getMutableIRBox(builder, loc, mutBox);
mlir::Value IntrinsicLibrary::genNot(mlir::Type resultType,
   return builder.create<mlir::arith::XOrIOp>(loc, args[0], allOnes);
 }
 
 // NULL
 fir::ExtendedValue
 IntrinsicLibrary::genNull(mlir::Type, llvm::ArrayRef<fir::ExtendedValue> args) {
   // NULL() without MOLD must be handled in the contexts where it can appear
   // (see table 16.5 of Fortran 2018 standard).
-  assert(args.size() == 1 && isPresent(args[0]) &&
+  assert(args.size() == 1 && isStaticallyPresent(args[0]) &&
          "MOLD argument required to lower NULL outside of any context");
   const auto *mold = args[0].getBoxOf<fir::MutableBoxValue>();
   assert(mold && "MOLD must be a pointer or allocatable");
   fir::BoxType boxType = mold->getBoxTy();
   mlir::Value boxStorage = builder.createTemporary(loc, boxType);
   mlir::Value box = fir::factory::createUnallocatedBox(
       builder, loc, boxType, mold->nonDeferredLenParams());
   builder.create<fir::StoreOp>(loc, box, boxStorage);
IntrinsicLibrary::genPack(mlir::Type resultType,
 
   // Handle required array argument
   mlir::Value array = builder.createBox(loc, args[0]);
 
   // Handle required mask argument
   mlir::Value mask = builder.createBox(loc, args[1]);
 
   // Handle optional vector argument
-  mlir::Value vector = isAbsent(args, 2)
+  mlir::Value vector = isStaticallyAbsent(args, 2)
                            ? builder.create<fir::AbsentOp>(
                                  loc, fir::BoxType::get(builder.getI1Type()))
                            : builder.createBox(loc, args[2]);
 
   // Create mutable fir.box to be passed to the runtime for the result.
   mlir::Type resultArrayType = builder.getVarLenSeqTy(resultType, 1);
   fir::MutableBoxValue resultMutableBox =
       fir::factory::createTempMutableBox(builder, loc, resultArrayType);
void IntrinsicLibrary::genRandomNumber(
   assert(args.size() == 1);
   Fortran::lower::genRandomNumber(builder, loc, fir::getBase(args[0]));
 }
 
 // RANDOM_SEED
 void IntrinsicLibrary::genRandomSeed(llvm::ArrayRef<fir::ExtendedValue> args) {
   assert(args.size() == 3);
   for (int i = 0; i < 3; ++i)
-    if (isPresent(args[i])) {
+    if (isStaticallyPresent(args[i])) {
       Fortran::lower::genRandomSeed(builder, loc, i, fir::getBase(args[i]));
       return;
     }
   Fortran::lower::genRandomSeed(builder, loc, -1, mlir::Value{});
 }
 
 // REPEAT
 fir::ExtendedValue
IntrinsicLibrary::genReshape(mlir::Type resultType,
   mlir::Type shapeTy = shape.getType();
   mlir::Type shapeArrTy = fir::dyn_cast_ptrOrBoxEleTy(shapeTy);
   auto resultRank = shapeArrTy.cast<fir::SequenceType>().getShape();
 
   assert(resultRank[0] != fir::SequenceType::getUnknownExtent() &&
          "shape arg must have constant size");
 
   // Handle optional pad argument
-  mlir::Value pad = isAbsent(args[2])
+  mlir::Value pad = isStaticallyAbsent(args[2])
                         ? builder.create<fir::AbsentOp>(
                               loc, fir::BoxType::get(builder.getI1Type()))
                         : builder.createBox(loc, args[2]);
 
   // Handle optional order argument
-  mlir::Value order = isAbsent(args[3])
+  mlir::Value order = isStaticallyAbsent(args[3])
                           ? builder.create<fir::AbsentOp>(
                                 loc, fir::BoxType::get(builder.getI1Type()))
                           : builder.createBox(loc, args[3]);
 
   // Create mutable fir.box to be passed to the runtime for the result.
   mlir::Type type = builder.getVarLenSeqTy(resultType, resultRank[0]);
   fir::MutableBoxValue resultMutableBox =
       fir::factory::createTempMutableBox(builder, loc, type);

 
 // SCAN
 fir::ExtendedValue
 IntrinsicLibrary::genScan(mlir::Type resultType,
                           llvm::ArrayRef<fir::ExtendedValue> args) {
 
   assert(args.size() == 4);
 
-  if (isAbsent(args[3])) {
+  if (isStaticallyAbsent(args[3])) {
     // Kind not specified, so call scan/verify runtime routine that is
     // specialized on the kind of characters in string.
 
     // Handle required string base arg
     mlir::Value stringBase = fir::getBase(args[0]);
 
     // Handle required set string base arg
     mlir::Value setBase = fir::getBase(args[1]);
 
     // Handle kind argument; it is the kind of character in this case
     fir::KindTy kind =
         fir::factory::CharacterExprHelper{builder, loc}.getCharacterKind(
             stringBase.getType());
 
     // Get string length argument
     mlir::Value stringLen = fir::getLen(args[0]);
 
     // Get set string length argument
     mlir::Value setLen = fir::getLen(args[1]);
 
     // Handle optional back argument
     mlir::Value back =
-        isAbsent(args[2])
+        isStaticallyAbsent(args[2])
             ? builder.createIntegerConstant(loc, builder.getI1Type(), 0)
             : fir::getBase(args[2]);
 
     return builder.createConvert(loc, resultType,
                                  fir::runtime::genScan(builder, loc, kind,
                                                        stringBase, stringLen,
                                                        setBase, setLen, back));
   }
if (boxValue->hasAssumedRank())
       TODO(loc, "SIZE intrinsic with assumed rank argument");
 
   // Get the ARRAY argument
   mlir::Value array = builder.createBox(loc, args[0]);
 
   // The front-end rewrites SIZE without the DIM argument to
   // an array of SIZE with DIM in most cases, but it may not be
   // possible in some cases like when in SIZE(function_call()).
-  if (isAbsent(args, 1))
+  if (isStaticallyAbsent(args, 1))
     return builder.createConvert(loc, resultType,
                                  fir::runtime::genSize(builder, loc, array));
 
   // Get the DIM argument.
   mlir::Value dim = fir::getBase(args[1]);
   if (!fir::isa_ref_type(dim.getType()))
     return builder.createConvert(
         loc, resultType, fir::runtime::genSizeDim(builder, loc, array, dim));
IntrinsicLibrary::genLbound(mlir::Type resultType,
   const fir::ExtendedValue &array = args[0];
   if (const auto *boxValue = array.getBoxOf<fir::BoxValue>())
     if (boxValue->hasAssumedRank())
       TODO(loc, "LBOUND intrinsic with assumed rank argument");
 
   //===----------------------------------------------------------------------===//
   mlir::Type indexType = builder.getIndexType();
 
-  if (isAbsent(args, 1)) {
+  if (isStaticallyAbsent(args, 1)) {
     mlir::Type lbType = fir::unwrapSequenceType(resultType);
     unsigned rank = array.rank();
     mlir::Type lbArrayType = fir::SequenceType::get(
         {static_cast<fir::SequenceType::Extent>(array.rank())}, lbType);
     mlir::Value lbArray = builder.createTemporary(loc, lbArrayType);
     mlir::Type lbAddrType = builder.getRefType(lbType);
     mlir::Value one = builder.createIntegerConstant(loc, lbType, 1);
     mlir::Value zero = builder.createIntegerConstant(loc, indexType, 0);
if (args.size() == 3) {
     mlir::Value extent = fir::getBase(genSize(resultType, args));
     mlir::Value lbound = fir::getBase(genLbound(resultType, args));
 
     mlir::Value one = builder.createIntegerConstant(loc, resultType, 1);
     mlir::Value ubound = builder.create<mlir::arith::SubIOp>(loc, lbound, one);
     return builder.create<mlir::arith::AddIOp>(loc, ubound, extent);
   } else {
     // Handle calls to UBOUND without the DIM argument, which return an array
-    mlir::Value kind = isAbsent(args[1])
+    mlir::Value kind = isStaticallyAbsent(args[1])
                            ? builder.createIntegerConstant(
                                  loc, builder.getIndexType(),
                                  builder.getKindMap().defaultIntegerKind())
                            : fir::getBase(args[1]);
 
     // Create mutable fir.box to be passed to the runtime for the result.
     mlir::Type type = builder.getVarLenSeqTy(resultType, /*rank=*/1);
     fir::MutableBoxValue resultMutableBox =

 
 // VERIFY
 fir::ExtendedValue
 IntrinsicLibrary::genVerify(mlir::Type resultType,
                             llvm::ArrayRef<fir::ExtendedValue> args) {
 
   assert(args.size() == 4);
 
-  if (isAbsent(args[3])) {
+  if (isStaticallyAbsent(args[3])) {
     // Kind not specified, so call scan/verify runtime routine that is
     // specialized on the kind of characters in string.
 
     // Handle required string base arg
     mlir::Value stringBase = fir::getBase(args[0]);
 
     // Handle required set string base arg
     mlir::Value setBase = fir::getBase(args[1]);
 
     // Handle kind argument; it is the kind of character in this case
     fir::KindTy kind =
         fir::factory::CharacterExprHelper{builder, loc}.getCharacterKind(
             stringBase.getType());
 
     // Get string length argument
     mlir::Value stringLen = fir::getLen(args[0]);
 
     // Get set string length argument
     mlir::Value setLen = fir::getLen(args[1]);
 
     // Handle optional back argument
     mlir::Value back =
-        isAbsent(args[2])
+        isStaticallyAbsent(args[2])
             ? builder.createIntegerConstant(loc, builder.getI1Type(), 0)
             : fir::getBase(args[2]);
 
     return builder.createConvert(
         loc, resultType,
         fir::runtime::genVerify(builder, loc, kind, stringBase, stringLen,
                                 setBase, setLen, back));
   }