[Flang] NFC: Changes to adhere to coding guidelines

[kiranchandramohan]

Summary

This patch includes some changes which brings the code in line with
llvm coding guidelines.
-> Remove curlies for one line if statements.
-> Remove else after return.
-> Removes a few usage of auto.
-> Add Doxygen comments

Addresses post review comments in D120403 by @schweitz.

[rovka]

flang/lib/Lower/IntrinsicCall.cpp

314

I think you're actually supposed to use braces here, there's an example in the LLVM coding style that says "Use braces for the outer if since the nested for is braced."
Anyway, I don't feel very strongly about it, so feel free to ignore.

[rovka]

flang/lib/Lower/IntrinsicCall.cpp

82

[kiranchandramohan]

Address review comments from @rovka.

[kiranchandramohan]

flang/lib/Lower/IntrinsicCall.cpp

314

Yes, makes sense and since it is mentioned in the guideline it is better to stick with it. I thought about it but didn't put the effort to check the coding style guide.

I have made the change.

[rovka]

Ok, thanks :) This LGTM, but since you're mostly addressing Eric's comments I'll let him give you the official blessing.

[schweitz]

I don't think always getting rid of type inferencing is really necessary and as code owner would accept using it.

flang/lib/Lower/IntrinsicCall.cpp

353–354

To avoid regressions. :)

[kiranchandramohan]

Add initialization to avoid regressions.

flang/lib/Lower/IntrinsicCall.cpp

mlir::Value genRuntimeCall(llvm::StringRef name, mlir::Type,
                              llvm::ArrayRef<mlir::Value>);
 
   using RuntimeCallGenerator = std::function<mlir::Value(
       fir::FirOpBuilder &, mlir::Location, llvm::ArrayRef<mlir::Value>)>;
   RuntimeCallGenerator
   getRuntimeCallGenerator(llvm::StringRef name,
                           mlir::FunctionType soughtFuncType);
 
+  /// Lowering for the ABS intrinsic. The ABS intrinsic expects one argument in
+  /// the llvm::ArrayRef. The ABS intrinsic is lowered into MLIR/FIR operation
+  /// if the argument is an integer, into llvm intrinsics if the argument is
+  /// real and to the `hypot` math routine if the argument is of complex type.
   mlir::Value genAbs(mlir::Type, llvm::ArrayRef<mlir::Value>);
+  /// Lowering for the IAND intrinsic. The IAND intrinsic expects two arguments
+  /// in the llvm::ArrayRef.
   mlir::Value genIand(mlir::Type, llvm::ArrayRef<mlir::Value>);
   /// Define the different FIR generators that can be mapped to intrinsic to
-  /// generate the related code.
+  /// generate the related code. The intrinsic is lowered into an MLIR
+  /// arith::AndIOp.
   using ElementalGenerator = decltype(&IntrinsicLibrary::genAbs);
   using Generator = std::variant<ElementalGenerator>;
 
   /// Generate calls to ElementalGenerator, handling the elemental aspects
   template <typename GeneratorType>
   fir::ExtendedValue
   genElementalCall(GeneratorType, llvm::StringRef name, mlir::Type resultType,
                    llvm::ArrayRef<fir::ExtendedValue> args, bool outline);
#define RUNTIME_STATIC_DESCRIPTION(name, func)                                 \
   {#name, #func, fir::runtime::RuntimeTableKey<decltype(func)>::getTypeModel()},
 static constexpr RuntimeFunction pgmathFast[] = {
 #define PGMATH_FAST
 #define PGMATH_USE_ALL_TYPES(name, func) RUNTIME_STATIC_DESCRIPTION(name, func)
 #include "flang/Evaluate/pgmath.h.inc"
 };
 
 static mlir::FunctionType genF32F32FuncType(mlir::MLIRContext *context) {
-  auto t = mlir::FloatType::getF32(context);
+  mlir::Type t = mlir::FloatType::getF32(context);
   return mlir::FunctionType::get(context, {t}, {t});
 }
 
 static mlir::FunctionType genF64F64FuncType(mlir::MLIRContext *context) {
-  auto t = mlir::FloatType::getF64(context);
+  mlir::Type t = mlir::FloatType::getF64(context);
   return mlir::FunctionType::get(context, {t}, {t});
 }
 
 static mlir::FunctionType genF32F32F32FuncType(mlir::MLIRContext *context) {
   auto t = mlir::FloatType::getF32(context);
   return mlir::FunctionType::get(context, {t, t}, {t});
 }
 
public:
   FunctionDistance() : infinite{true} {}
 
   FunctionDistance(mlir::FunctionType from, mlir::FunctionType to) {
     unsigned nInputs = from.getNumInputs();
     unsigned nResults = from.getNumResults();
     if (nResults != to.getNumResults() || nInputs != to.getNumInputs()) {
       infinite = true;
     } else {
-      for (decltype(nInputs) i{0}; i < nInputs && !infinite; ++i)
+      for (decltype(nInputs) i = 0; i < nInputs && !infinite; ++i)
         addArgumentDistance(from.getInput(i), to.getInput(i));
-      for (decltype(nResults) i{0}; i < nResults && !infinite; ++i)
+      for (decltype(nResults) i = 0; i < nResults && !infinite; ++i)
         addResultDistance(to.getResult(i), from.getResult(i));
     }
   }
 
   /// Beware both d1.isSmallerThan(d2) *and* d2.isSmallerThan(d1) may be
   /// false if both d1 and d2 are infinite. This implies that
   ///  d1.isSmallerThan(d2) is not equivalent to !d2.isSmallerThan(d1)
   bool isSmallerThan(const FunctionDistance &d) const {
static unsigned getFloatingPointWidth(mlir::Type t) {
     if (auto r{t.dyn_cast<fir::RealType>()})
       return r.getFKind() * 4;
     if (auto cplx{t.dyn_cast<fir::ComplexType>()})
       return cplx.getFKind() * 4;
     llvm_unreachable("not a floating-point type");
   }
 
   static Conversion conversionBetweenTypes(mlir::Type from, mlir::Type to) {
-    if (from == to) {
+    if (from == to)
       return Conversion::None;
-    }
+
     if (auto fromIntTy{from.dyn_cast<mlir::IntegerType>()}) {
       if (auto toIntTy{to.dyn_cast<mlir::IntegerType>()}) {
         return fromIntTy.getWidth() > toIntTy.getWidth() ? Conversion::Narrow
                                                          : Conversion::Extend;
       }
     }
+
     if (fir::isa_real(from) && fir::isa_real(to)) {
       return getFloatingPointWidth(from) > getFloatingPointWidth(to)
                  ? Conversion::Narrow
                  : Conversion::Extend;
     }
+
     if (auto fromCplxTy{from.dyn_cast<fir::ComplexType>()}) {
       if (auto toCplxTy{to.dyn_cast<fir::ComplexType>()}) {
         return getFloatingPointWidth(fromCplxTy) >
                        getFloatingPointWidth(toCplxTy)
                    ? Conversion::Narrow
                    : Conversion::Extend;
       }
     }
private:
   enum {
     narrowingArg = 0,   // usually bad
     extendingResult,    // usually bad
     nonExtendingResult, // usually ok
     nonNarrowingArg,    // usually ok
     dataSize
   };
 
-  std::array<int, dataSize> conversions{/* zero init*/};
-  bool infinite{false}; // When forbidden conversion or wrong argument number
+  std::array<int, dataSize> conversions = {};
+  bool infinite = false; // When forbidden conversion or wrong argument number
 };
 
 /// Build mlir::FuncOp from runtime symbol description and add
 /// fir.runtime attribute.
 static mlir::FuncOp getFuncOp(mlir::Location loc, fir::FirOpBuilder &builder,
                               const RuntimeFunction &runtime) {
   mlir::FuncOp function = builder.addNamedFunction(
       loc, runtime.symbol, runtime.typeGenerator(builder.getContext()));
   function->setAttr("fir.runtime", builder.getUnitAttr());
   return function;
 }
 
 /// Select runtime function that has the smallest distance to the intrinsic
 /// function type and that will not imply narrowing arguments or extending the
 /// result.
 /// If nothing is found, the mlir::FuncOp will contain a nullptr.
 mlir::FuncOp searchFunctionInLibrary(
     mlir::Location loc, fir::FirOpBuilder &builder,
     const Fortran::common::StaticMultimapView<RuntimeFunction> &lib,
     llvm::StringRef name, mlir::FunctionType funcType,
     const RuntimeFunction **bestNearMatch,
     FunctionDistance &bestMatchDistance) {
-  auto range = lib.equal_range(name);
-  for (auto iter{range.first}; iter != range.second && iter; ++iter) {
-    const auto &impl = *iter;
-    auto implType = impl.typeGenerator(builder.getContext());
-    if (funcType == implType) {
+  std::pair<const RuntimeFunction *, const RuntimeFunction *> range =
+      lib.equal_range(name);
+  for (auto iter = range.first; iter != range.second && iter; ++iter) {
+    const RuntimeFunction &impl = *iter;
+    mlir::FunctionType implType = impl.typeGenerator(builder.getContext());
+    if (funcType == implType)
       return getFuncOp(loc, builder, impl); // exact match
-    } else {
-      FunctionDistance distance(funcType, implType);
-      if (distance.isSmallerThan(bestMatchDistance)) {
-        *bestNearMatch = &impl;
-        bestMatchDistance = std::move(distance);
-      }
-    }
-  }
+
   return {};
 }
 
 /// Search runtime for the best runtime function given an intrinsic name
 /// and interface. The interface may not be a perfect match in which case
 /// the caller is responsible to insert argument and return value conversions.
 /// If nothing is found, the mlir::FuncOp will contain a nullptr.
 static mlir::FuncOp getRuntimeFunction(mlir::Location loc,

 
 // ABS
 mlir::Value IntrinsicLibrary::genAbs(mlir::Type resultType,
                                      llvm::ArrayRef<mlir::Value> args) {
   assert(args.size() == 1);
   mlir::Value arg = args[0];
   mlir::Type type = arg.getType();
   if (fir::isa_real(type)) {
-    // Runtime call to fp abs. An alternative would be to use mlir math::AbsFOp
-    // but it does not support all fir floating point types.
+    // Runtime call to fp abs. An alternative would be to use mlir
+    // math::AbsFOp but it does not support all fir floating point types.
     return genRuntimeCall("abs", resultType, args);
   }
   if (auto intType = type.dyn_cast<mlir::IntegerType>()) {
     // At the time of this implementation there is no abs op in mlir.
     // So, implement abs here without branching.
     mlir::Value shift =
         builder.createIntegerConstant(loc, intType, intType.getWidth() - 1);
     auto mask = builder.create<mlir::arith::ShRSIOp>(loc, arg, shift);