[flang][NFC] Remove CallBuilder class

[jeanPerier]

Summary

The methods of CallBuilder do need to belong to a class.
This was made to avoid having to propagate generic lowering context
(converter, symbol mappings, location and StatementContext).

Packaging them together will actually make it harder to share the code
for user and intrinsic elemental lowering (I plan to use C++ CRTP),
and it is also misleading: one could think there is something going
with the class state while lowering the function while there is not
(and there should not be).

Removes the class and turns the methods into static functions.
Add a new CallContext class to solve the argument threading
inconvenience.

This contains no functional changes at all.

[clementval]

LGTM

[PeteSteinfeld]

Things build and test correctly and look good.

flang/lib/Lower/ConvertCall.cpp

660–694

Should this say "elemental"?

flang/lib/Lower/ConvertCall.cpp

static hlfir::EntityWithAttributes genStmtFunctionRef(
   result = hlfir::loadTrivialScalar(loc, builder, result);
   if (result.isVariable())
     result = hlfir::Entity{builder.create<hlfir::AsExprOp>(loc, result)};
   for (auto associate : exprAssociations)
     builder.create<hlfir::EndAssociateOp>(loc, associate);
   return hlfir::EntityWithAttributes{result};
 }
 
+namespace {
+// Structure to hold the information about the call and the lowering context.
+// This structure is intended to help threading the information
+// through the various lowering calls without having to pass every
+// required structure one by one.
+struct CallContext {
+  CallContext(const Fortran::evaluate::ProcedureRef &procRef,
+              std::optional<mlir::Type> resultType, mlir::Location loc,
+              Fortran::lower::AbstractConverter &converter,
+              Fortran::lower::SymMap &symMap,
+              Fortran::lower::StatementContext &stmtCtx)
+      : procRef{procRef}, converter{converter}, symMap{symMap},
+        stmtCtx{stmtCtx}, resultType{resultType}, loc{loc} {}
+
+  fir::FirOpBuilder &getBuilder() { return converter.getFirOpBuilder(); }
+
   /// Is this a call to an elemental procedure with at least one array argument?
-static bool
-isElementalProcWithArrayArgs(const Fortran::evaluate::ProcedureRef &procRef) {
+  bool isElementalProcWithArrayArgs() const {
     if (procRef.IsElemental())
       for (const std::optional<Fortran::evaluate::ActualArgument> &arg :
            procRef.arguments())
         if (arg && arg->Rank() != 0)
           return true;
     return false;
   }
 
-/// helper to detect statement functions
-static bool
-isStatementFunctionCall(const Fortran::evaluate::ProcedureRef &procRef) {
+  /// Is this a statement function reference?
+  bool isStatementFunctionCall() const {
     if (const Fortran::semantics::Symbol *symbol = procRef.proc().GetSymbol())
       if (const auto *details =
               symbol->detailsIf<Fortran::semantics::SubprogramDetails>())
         return details->stmtFunction().has_value();
     return false;
   }
 
-namespace {
-class CallBuilder {
-private:
-  struct PreparedActualArgument {
-    hlfir::Entity actual;
-    bool handleDynamicOptional;
-  };
-  using PreparedActualArguments =
-      llvm::SmallVector<std::optional<PreparedActualArgument>>;
-  using PassBy = Fortran::lower::CallerInterface::PassEntityBy;
-
-public:
-  CallBuilder(mlir::Location loc, Fortran::lower::AbstractConverter &converter,
-              Fortran::lower::SymMap &symMap,
-              Fortran::lower::StatementContext &stmtCtx)
-      : converter{converter}, symMap{symMap}, stmtCtx{stmtCtx}, loc{loc} {}
-
-  std::optional<hlfir::EntityWithAttributes>
-  gen(const Fortran::evaluate::ProcedureRef &procRef,
-      std::optional<mlir::Type> resultType) {
-    mlir::Location loc = getLoc();
-    if (auto *specific = procRef.proc().GetSpecificIntrinsic()) {
-      if (isElementalProcWithArrayArgs(procRef))
-        TODO(loc, "lowering elemental intrinsic call to HLFIR");
-      return genIntrinsicRef(procRef, resultType, *specific);
-    }
-    if (isStatementFunctionCall(procRef))
-      return genStmtFunctionRef(loc, converter, symMap, stmtCtx, procRef);
+  const Fortran::evaluate::ProcedureRef &procRef;
+  Fortran::lower::AbstractConverter &converter;
+  Fortran::lower::SymMap &symMap;
+  Fortran::lower::StatementContext &stmtCtx;
+  std::optional<mlir::Type> resultType;
+  mlir::Location loc;
+};
+
+/// This structure holds the initial lowered value of an actual argument that
+/// was lowered regardless of the interface, and it holds whether or not it
+/// may be absent at runtime and the dummy is optional.
+} // namespace
+
+/// Vector of pre-lowered actual arguments. nullopt if the actual is
+/// "statically" absent (if it was not syntactically  provided).
 
-    Fortran::lower::CallerInterface caller(procRef, converter);
-    mlir::FunctionType callSiteType = caller.genFunctionType();
-
-    PreparedActualArguments loweredActuals;
-    // Lower the actual arguments
-    for (const Fortran::lower::CallInterface<
-             Fortran::lower::CallerInterface>::PassedEntity &arg :
-         caller.getPassedArguments())
-      if (const auto *actual = arg.entity) {
-        const auto *expr = actual->UnwrapExpr();
-        if (!expr)
-          TODO(loc, "assumed type actual argument");
-
-        const bool handleDynamicOptional =
-            arg.isOptional() && Fortran::evaluate::MayBePassedAsAbsentOptional(
-                                    *expr, getConverter().getFoldingContext());
-        auto loweredActual = Fortran::lower::convertExprToHLFIR(
-            loc, getConverter(), *expr, getSymMap(), getStmtCtx());
-        loweredActuals.emplace_back(
-            PreparedActualArgument{loweredActual, handleDynamicOptional});
-      } else {
-        // Optional dummy argument for which there is no actual argument.
-        loweredActuals.emplace_back(std::nullopt);
-      }
-    if (isElementalProcWithArrayArgs(procRef)) {
-      bool isImpure = false;
-      if (const Fortran::semantics::Symbol *procSym =
-              procRef.proc().GetSymbol())
-        isImpure = !Fortran::semantics::IsPureProcedure(*procSym);
-      return genElementalUserCall(loweredActuals, caller, resultType,
-                                  callSiteType, isImpure);
-    }
-    return genUserCall(loweredActuals, caller, resultType, callSiteType);
-  }
+// Helper to transform a fir::ExtendedValue to an hlfir::EntityWithAttributes.
+static hlfir::EntityWithAttributes
+extendedValueToHlfirEntity(mlir::Location loc, fir::FirOpBuilder &builder,
+                           const fir::ExtendedValue &exv,
+                           llvm::StringRef name) {
+  mlir::Value firBase = fir::getBase(exv);
+  if (fir::isa_trivial(firBase.getType()))
+    return hlfir::EntityWithAttributes{firBase};
+  return hlfir::genDeclare(loc, builder, exv, name,
+                           fir::FortranVariableFlagsAttr{});
 
-private:
-  std::optional<hlfir::EntityWithAttributes>
-  genUserCall(PreparedActualArguments &loweredActuals,
-              Fortran::lower::CallerInterface &caller,
-              std::optional<mlir::Type> resultType,
-              mlir::FunctionType callSiteType) {
-    mlir::Location loc = getLoc();
-    fir::FirOpBuilder &builder = getBuilder();
-    llvm::SmallVector<hlfir::AssociateOp> exprAssociations;
-    for (auto [preparedActual, arg] :
-         llvm::zip(loweredActuals, caller.getPassedArguments())) {
-      mlir::Type argTy = callSiteType.getInput(arg.firArgument);
-      if (!preparedActual) {
-        // Optional dummy argument for which there is no actual argument.
-        caller.placeInput(arg, builder.create<fir::AbsentOp>(loc, argTy));
-        continue;
-      }
-      hlfir::Entity actual = preparedActual->actual;
-      const auto *expr = arg.entity->UnwrapExpr();
-      if (!expr)
-        TODO(loc, "assumed type actual argument");
+/// Lower calls to user procedures with actual arguments that have been
+/// pre-lowered but not yet prepared according to the interface.
+/// This can be called for elemental procedures, but only with scalar
+/// arguments: if there are array arguments, it must be provided with
+/// the array argument elements value and will return the corresponding
+/// scalar result value.
+static std::optional<hlfir::EntityWithAttributes>
+            mlir::FunctionType callSiteType, CallContext &callContext) {
+  using PassBy = Fortran::lower::CallerInterface::PassEntityBy;
+  mlir::Location loc = callContext.loc;
+  fir::FirOpBuilder &builder = callContext.getBuilder();
 
-      if (preparedActual->handleDynamicOptional)
-        TODO(loc, "passing optional arguments in HLFIR");
 
-      const bool isSimplyContiguous =
-          actual.isScalar() || Fortran::evaluate::IsSimplyContiguous(
-                                   *expr, getConverter().getFoldingContext());
+        actual.isScalar() ||
+        Fortran::evaluate::IsSimplyContiguous(
+            *expr, callContext.converter.getFoldingContext());
 
-      switch (arg.passBy) {
-      case PassBy::Value: {
-        // True pass-by-value semantics.
-        auto value = hlfir::loadTrivialScalar(loc, builder, actual);
-        if (!value.isValue())
-          TODO(loc, "Passing CPTR an CFUNCTPTR VALUE in HLFIR");
-        caller.placeInput(arg, builder.createConvert(loc, argTy, value));
-      } break;
-      case PassBy::BaseAddressValueAttribute: {
-        // VALUE attribute or pass-by-reference to a copy semantics. (byval*)
-        TODO(loc, "HLFIR PassBy::BaseAddressValueAttribute");
-      } break;
-      case PassBy::BaseAddress:
-      case PassBy::BoxChar: {
-        hlfir::Entity entity = actual;
-        if (entity.isVariable()) {
-          entity = hlfir::derefPointersAndAllocatables(loc, builder, entity);
-          // Copy-in non contiguous variable
-          if (!isSimplyContiguous)
-            TODO(loc, "HLFIR copy-in/copy-out");
-        } else {
-          hlfir::AssociateOp associate = hlfir::genAssociateExpr(
-              loc, builder, entity, argTy, "adapt.valuebyref");
-          exprAssociations.push_back(associate);
-          entity = hlfir::Entity{associate.getBase()};
-        }
-        mlir::Value addr =
-            arg.passBy == PassBy::BaseAddress
-                ? hlfir::genVariableRawAddress(loc, builder, entity)
-                : hlfir::genVariableBoxChar(loc, builder, entity);
-        caller.placeInput(arg, builder.createConvert(loc, argTy, addr));
-      } break;
-      case PassBy::CharBoxValueAttribute: {
-        TODO(loc, "HLFIR PassBy::CharBoxValueAttribute");
-      } break;
-      case PassBy::AddressAndLength:
-        // PassBy::AddressAndLength is only used for character results. Results
-        // are not handled here.
-        fir::emitFatalError(
-            loc, "unexpected PassBy::AddressAndLength for actual arguments");
-        break;
-      case PassBy::CharProcTuple: {
-        TODO(loc, "HLFIR PassBy::CharProcTuple");
-      } break;
-      case PassBy::Box: {
-        TODO(loc, "HLFIR PassBy::Box");
-      } break;
-      case PassBy::MutableBox: {
-        TODO(loc, "HLFIR PassBy::MutableBox");
-      } break;
-      }
-    }
-    // Prepare lowered arguments according to the interface
-    // and map the lowered values to the dummy
-    // arguments.
-    fir::ExtendedValue result = Fortran::lower::genCallOpAndResult(
-        loc, getConverter(), getSymMap(), getStmtCtx(), caller, callSiteType,
-        resultType);
+      loc, callContext.converter, callContext.symMap, callContext.stmtCtx,
+      caller, callSiteType, callContext.resultType);
 
-    /// Clean-up associations and copy-in.
-    for (auto associate : exprAssociations)
-      builder.create<hlfir::EndAssociateOp>(loc, associate);
-    if (!fir::getBase(result))
-      return std::nullopt; // subroutine call.
-    // TODO: "move" non pointer results into hlfir.expr.
-    return extendedValueToHlfirEntity(result, ".tmp.func_result");
-  }
+  return extendedValueToHlfirEntity(loc, builder, result, ".tmp.func_result");
 
-  std::optional<hlfir::EntityWithAttributes>
-  genElementalUserCall(PreparedActualArguments &loweredActuals,
-                       Fortran::lower::CallerInterface &caller,
-                       std::optional<mlir::Type> resultType,
-                       mlir::FunctionType callSiteType, bool isImpure) {
-    mlir::Location loc = getLoc();
-    fir::FirOpBuilder &builder = getBuilder();
-    assert(loweredActuals.size() == caller.getPassedArguments().size());
-    unsigned numArgs = loweredActuals.size();
-    // Step 1: dereference pointers/allocatables and compute elemental shape.
-    mlir::Value shape;
-    // 10.1.4 p5. Impure elemental procedures must be called in element order.
-    bool mustBeOrdered = isImpure;
-    for (unsigned i = 0; i < numArgs; ++i) {
-      const auto &arg = caller.getPassedArguments()[i];
-      auto &preparedActual = loweredActuals[i];
-      if (preparedActual) {
-        hlfir::Entity &actual = preparedActual->actual;
-        // Elemental procedure dummy arguments cannot be pointer/allocatables
-        // (C15100), so it is safe to dereference any pointer or allocatable
-        // actual argument now instead of doing this inside the elemental
-        // region.
-        actual = hlfir::derefPointersAndAllocatables(loc, builder, actual);
-        // Better to load scalars outside of the loop when possible.
-        if (!preparedActual->handleDynamicOptional &&
-            (arg.passBy == PassBy::Value ||
-             arg.passBy == PassBy::BaseAddressValueAttribute))
-          actual = hlfir::loadTrivialScalar(loc, builder, actual);
-        // TODO: merge shape instead of using the first one.
-        if (!shape && actual.isArray()) {
-          if (preparedActual->handleDynamicOptional)
-            TODO(loc, "deal with optional with shapes in HLFIR elemental call");
-          shape = hlfir::genShape(loc, builder, actual);
-        }
-        // 15.8.3 p1. Elemental procedure with intent(out)/intent(inout)
-        // arguments must be called in element order.
-        if (arg.mayBeModifiedByCall())
-          mustBeOrdered = true;
-      }
-    }
-    assert(shape &&
-           "elemental array calls must have at least one array arguments");
-    if (mustBeOrdered)
-      TODO(loc, "ordered elemental calls in HLFIR");
-    if (!resultType) {
-      // Subroutine case. Generate call inside loop nest.
-      auto [innerLoop, oneBasedIndices] =
-          hlfir::genLoopNest(loc, builder, shape);
-      auto insPt = builder.saveInsertionPoint();
-      builder.setInsertionPointToStart(innerLoop.getBody());
-      for (auto &preparedActual : loweredActuals)
-        if (preparedActual)
-          preparedActual->actual = hlfir::getElementAt(
-              loc, builder, preparedActual->actual, oneBasedIndices);
-      genUserCall(loweredActuals, caller, resultType, callSiteType);
-      builder.restoreInsertionPoint(insPt);
-      return std::nullopt;
-    }
-    // Function case: generate call inside hlfir.elemental
-    mlir::Type elementType = hlfir::getFortranElementType(*resultType);
-    // Get result length parameters.
-    llvm::SmallVector<mlir::Value> typeParams;
-    if (elementType.isa<fir::CharacterType>() ||
-        fir::isRecordWithTypeParameters(elementType))
-      TODO(loc, "compute elemental function result length parameters in HLFIR");
-    auto genKernel = [&](mlir::Location l, fir::FirOpBuilder &b,
-                         mlir::ValueRange oneBasedIndices) -> hlfir::Entity {
-      for (auto &preparedActual : loweredActuals)
-        if (preparedActual)
-          preparedActual->actual = hlfir::getElementAt(
-              l, b, preparedActual->actual, oneBasedIndices);
-      return *genUserCall(loweredActuals, caller, resultType, callSiteType);
-    };
-    // TODO: deal with hlfir.elemental result destruction.
-    return hlfir::EntityWithAttributes{hlfir::genElementalOp(
-        loc, builder, elementType, shape, typeParams, genKernel)};
-  }
+/// Lower calls to elemental user procedure with array actual arguments.
+static std::optional<hlfir::EntityWithAttributes>
+                     mlir::FunctionType callSiteType, bool isImpure,
+                     CallContext &callContext) {
+  using PassBy = Fortran::lower::CallerInterface::PassEntityBy;
+  mlir::Location loc = callContext.loc;
+  fir::FirOpBuilder &builder = callContext.getBuilder();
+  if (!callContext.resultType) {
+    auto [innerLoop, oneBasedIndices] = hlfir::genLoopNest(loc, builder, shape);
+    genUserCall(loweredActuals, caller, callSiteType, callContext);
+  mlir::Type elementType =
+      hlfir::getFortranElementType(*callContext.resultType);
+        preparedActual->actual =
+            hlfir::getElementAt(l, b, preparedActual->actual, oneBasedIndices);
+    return *genUserCall(loweredActuals, caller, callSiteType, callContext);
 
-  hlfir::EntityWithAttributes
-  genIntrinsicRef(const Fortran::evaluate::ProcedureRef &procRef,
-                  std::optional<mlir::Type> resultType,
-                  const Fortran::evaluate::SpecificIntrinsic &intrinsic) {
-    mlir::Location loc = getLoc();
-    if (Fortran::lower::intrinsicRequiresCustomOptionalHandling(
-            procRef, intrinsic, converter))
-      TODO(loc, "special cases of intrinsic with optional arguments");
+/// Lower an intrinsic procedure reference.
+static hlfir::EntityWithAttributes
+genIntrinsicRef(const Fortran::evaluate::SpecificIntrinsic &intrinsic,
+                CallContext &callContext) {
+  mlir::Location loc = callContext.loc;
+  auto &converter = callContext.converter;
+  auto &stmtCtx = callContext.stmtCtx;
+          callContext.procRef, intrinsic, converter))
+  if (callContext.isElementalProcWithArrayArgs())
+    TODO(loc, "lowering elemental intrinsic call to HLFIR");
 
-    llvm::SmallVector<fir::ExtendedValue> operands;
-    const Fortran::lower::IntrinsicArgumentLoweringRules *argLowering =
-        Fortran::lower::getIntrinsicArgumentLowering(intrinsic.name);
-    for (const auto &arg : llvm::enumerate(procRef.arguments())) {
-      auto *expr =
-          Fortran::evaluate::UnwrapExpr<Fortran::lower::SomeExpr>(arg.value());
-      if (!expr) {
-        // Absent optional.
-        operands.emplace_back(Fortran::lower::getAbsentIntrinsicArgument());
-        continue;
-      }
-      if (!argLowering) {
-        // No argument lowering instruction, lower by value.
-        operands.emplace_back(converter.genExprValue(loc, *expr, stmtCtx));
-        continue;
-      }
-      // Ad-hoc argument lowering handling.
-      Fortran::lower::ArgLoweringRule argRules =
-          Fortran::lower::lowerIntrinsicArgumentAs(*argLowering, arg.index());
-      if (argRules.handleDynamicOptional &&
-          Fortran::evaluate::MayBePassedAsAbsentOptional(
-              *expr, converter.getFoldingContext()))
-        TODO(loc, "intrinsic dynamically optional arguments");
-      switch (argRules.lowerAs) {
-      case Fortran::lower::LowerIntrinsicArgAs::Value:
-        operands.emplace_back(converter.genExprValue(loc, *expr, stmtCtx));
-        continue;
-      case Fortran::lower::LowerIntrinsicArgAs::Addr:
-        operands.emplace_back(converter.genExprAddr(loc, *expr, stmtCtx));
-        continue;
-      case Fortran::lower::LowerIntrinsicArgAs::Box:
-        operands.emplace_back(converter.genExprBox(loc, *expr, stmtCtx));
-        continue;
-      case Fortran::lower::LowerIntrinsicArgAs::Inquired:
-        TODO(loc, "as inquired arguments in HLFIR");
-        continue;
-      }
-      llvm_unreachable("bad switch");
-    }
-    // Let the intrinsic library lower the intrinsic procedure call
-    fir::ExtendedValue val = Fortran::lower::genIntrinsicCall(
-        getBuilder(), getLoc(), intrinsic.name, resultType, operands, stmtCtx);
-    return extendedValueToHlfirEntity(val, ".tmp.intrinsic_result");
-  }
+  // Lower arguments to ... hlfir::Entity.
+  // Create elem context.
+  // Call inside code.
+  for (const auto &arg : llvm::enumerate(callContext.procRef.arguments())) {
+  // Let the intrinsic library lower the intrinsic procedure call.
+      callContext.getBuilder(), loc, intrinsic.name, callContext.resultType,
+      operands, stmtCtx);
+  return extendedValueToHlfirEntity(loc, callContext.getBuilder(), val,
+                                    ".tmp.intrinsic_result");
+}
+
+/// Main entry point to lower procedure references, regardless of what they are.
+static std::optional<hlfir::EntityWithAttributes>
+genProcedureRef(CallContext &callContext) {
+  mlir::Location loc = callContext.loc;
+  if (auto *intrinsic = callContext.procRef.proc().GetSpecificIntrinsic())
+    return genIntrinsicRef(*intrinsic, callContext);
+
+  if (callContext.isStatementFunctionCall())
+    return genStmtFunctionRef(loc, callContext.converter, callContext.symMap,
+                              callContext.stmtCtx, callContext.procRef);
 
-  hlfir::EntityWithAttributes
-  extendedValueToHlfirEntity(const fir::ExtendedValue &exv,
-                             llvm::StringRef name) {
-    mlir::Value firBase = fir::getBase(exv);
-    if (fir::isa_trivial(firBase.getType()))
-      return hlfir::EntityWithAttributes{firBase};
-    return hlfir::genDeclare(getLoc(), getBuilder(), exv, name,
-                             fir::FortranVariableFlagsAttr{});
-  }
+  Fortran::lower::CallerInterface caller(callContext.procRef,
+                                         callContext.converter);
+  mlir::FunctionType callSiteType = caller.genFunctionType();
 
-  mlir::Location getLoc() const { return loc; }
-  Fortran::lower::AbstractConverter &getConverter() { return converter; }
-  fir::FirOpBuilder &getBuilder() { return converter.getFirOpBuilder(); }
-  Fortran::lower::SymMap &getSymMap() { return symMap; }
-  Fortran::lower::StatementContext &getStmtCtx() { return stmtCtx; }
+  PreparedActualArguments loweredActuals;
+  // Lower the actual arguments
+  for (const Fortran::lower::CallInterface<
+           Fortran::lower::CallerInterface>::PassedEntity &arg :
+       caller.getPassedArguments())
+    if (const auto *actual = arg.entity) {
+      const auto *expr = actual->UnwrapExpr();
+      if (!expr)
+        TODO(loc, "assumed type actual argument");
 
-  Fortran::lower::AbstractConverter &converter;
-  Fortran::lower::SymMap &symMap;
-  Fortran::lower::StatementContext &stmtCtx;
-  mlir::Location loc;
-};
-} // namespace
+      const bool handleDynamicOptional =
+          arg.isOptional() &&
+          Fortran::evaluate::MayBePassedAsAbsentOptional(
+              *expr, callContext.converter.getFoldingContext());
+      auto loweredActual = Fortran::lower::convertExprToHLFIR(
+          loc, callContext.converter, *expr, callContext.symMap,
+          callContext.stmtCtx);
+      loweredActuals.emplace_back(
+          PreparedActualArgument{loweredActual, handleDynamicOptional});
+    } else {
+      // Optional dummy argument for which there is no actual argument.
+      loweredActuals.emplace_back(std::nullopt);
+    }
+  if (callContext.isElementalProcWithArrayArgs()) {
+    bool isImpure = false;
+    if (const Fortran::semantics::Symbol *procSym =
+            callContext.procRef.proc().GetSymbol())
+      isImpure = !Fortran::semantics::IsPureProcedure(*procSym);
+    return genElementalUserCall(loweredActuals, caller, callSiteType, isImpure,
+                                callContext);
+  }
+  return genUserCall(loweredActuals, caller, callSiteType, callContext);
+}
 
 std::optional<hlfir::EntityWithAttributes> Fortran::lower::convertCallToHLFIR(
     mlir::Location loc, Fortran::lower::AbstractConverter &converter,
     const evaluate::ProcedureRef &procRef, std::optional<mlir::Type> resultType,
     Fortran::lower::SymMap &symMap, Fortran::lower::StatementContext &stmtCtx) {
-  return CallBuilder(loc, converter, symMap, stmtCtx).gen(procRef, resultType);
+  CallContext callContext(procRef, resultType, loc, converter, symMap, stmtCtx);
+  return genProcedureRef(callContext);
 }