[fir][NFC] Fix couple of clang-tidy warnings

[clementval]

Summary

Fix some clang-tidy wrning in flang/Optimizer/Support and
remove explicit number of inlined elements for SmallVector. This
is mostly to sync with the changes from fir-dev.

This patch is part of the upstreaming effort from fir-dev branch.

flang/include/flang/Optimizer/Support/FIRContext.h

 #ifndef FORTRAN_OPTIMIZER_SUPPORT_FIRCONTEXT_H
 #define FORTRAN_OPTIMIZER_SUPPORT_FIRCONTEXT_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 
 namespace mlir {
 class ModuleOp;
-}
+} // namespace mlir
 
 namespace fir {
 class KindMapping;
 struct NameUniquer;
 
 /// Set the target triple for the module. `triple` must not be deallocated while
 /// module `mod` is still live.
 void setTargetTriple(mlir::ModuleOp mod, llvm::StringRef triple);

flang/include/flang/Optimizer/Support/InternalNames.h

struct NameUniquer {
   struct DeconstructedName {
     DeconstructedName(llvm::StringRef name) : name{name} {}
     DeconstructedName(llvm::ArrayRef<std::string> modules,
                       llvm::Optional<std::string> host, llvm::StringRef name,
                       llvm::ArrayRef<std::int64_t> kinds)
         : modules{modules.begin(), modules.end()}, host{host}, name{name},
           kinds{kinds.begin(), kinds.end()} {}
 
-    llvm::SmallVector<std::string, 2> modules;
+    llvm::SmallVector<std::string> modules;
     llvm::Optional<std::string> host;
     std::string name;
-    llvm::SmallVector<std::int64_t, 4> kinds;
+    llvm::SmallVector<std::int64_t> kinds;
   };
 
   /// Unique a common block name
   static std::string doCommonBlock(llvm::StringRef name);
 
   /// Unique a block data unit name
   static std::string doBlockData(llvm::StringRef name);
 

flang/lib/Optimizer/Support/FIRContext.cpp

if (auto target = mod->getAttrOfType<mlir::StringAttr>(tripleName))
     return llvm::Triple(target.getValue());
   return llvm::Triple(llvm::sys::getDefaultTargetTriple());
 }
 
 static constexpr const char *kindMapName = "fir.kindmap";
 static constexpr const char *defKindName = "fir.defaultkind";
 
 void fir::setKindMapping(mlir::ModuleOp mod, fir::KindMapping &kindMap) {
-  auto ctx = mod.getContext();
+  auto *ctx = mod.getContext();
   mod->setAttr(kindMapName, mlir::StringAttr::get(ctx, kindMap.mapToString()));
   auto defs = kindMap.defaultsToString();
   mod->setAttr(defKindName, mlir::StringAttr::get(ctx, defs));
 }
 
 fir::KindMapping fir::getKindMapping(mlir::ModuleOp mod) {
-  auto ctx = mod.getContext();
+  auto *ctx = mod.getContext();
   if (auto defs = mod->getAttrOfType<mlir::StringAttr>(defKindName)) {
     auto defVals = fir::KindMapping::toDefaultKinds(defs.getValue());
     if (auto maps = mod->getAttrOfType<mlir::StringAttr>(kindMapName))
       return fir::KindMapping(ctx, maps.getValue(), defVals);
     return fir::KindMapping(ctx, defVals);
   }
   return fir::KindMapping(ctx);
 }

flang/lib/Optimizer/Support/InternalNames.cpp

 #include "mlir/IR/Diagnostics.h"
 #include "llvm/Support/CommandLine.h"
 
 static llvm::cl::opt<std::string> mainEntryName(
     "main-entry-name",
     llvm::cl::desc("override the name of the default PROGRAM entry (may be "
                    "helpful for using other runtimes)"));
 
-constexpr std::int64_t BAD_VALUE = -1;
+constexpr std::int64_t badValue = -1;
 
 inline std::string prefix() { return "_Q"; }
 
 static std::string doModules(llvm::ArrayRef<llvm::StringRef> mods) {
   std::string result;
   auto *token = "M";
   for (auto mod : mods) {
     result.append(token).append(mod.lower());
static std::string readName(llvm::StringRef uniq, std::size_t &i,
   return uniq.substr(init, i - init).str();
 }
 
 static std::int64_t readInt(llvm::StringRef uniq, std::size_t &i,
                             std::size_t init, std::size_t end) {
   for (i = init; i < end && uniq[i] >= '0' && uniq[i] <= '9'; ++i) {
     // do nothing
   }
-  std::int64_t result = BAD_VALUE;
+  std::int64_t result = badValue;
   if (uniq.substr(init, i - init).getAsInteger(10, result))
-    return BAD_VALUE;
+    return badValue;
   return result;
 }
 
 std::string fir::NameUniquer::toLower(llvm::StringRef name) {
   return name.lower();
 }
 
 std::string fir::NameUniquer::intAsString(std::int64_t i) {
llvm::StringRef fir::NameUniquer::doProgramEntry() {
   if (mainEntryName.size())
     return mainEntryName;
   return "_QQmain";
 }
 
 std::pair<fir::NameUniquer::NameKind, fir::NameUniquer::DeconstructedName>
 fir::NameUniquer::deconstruct(llvm::StringRef uniq) {
   if (uniq.startswith("_Q")) {
-    llvm::SmallVector<std::string, 4> modules;
+    llvm::SmallVector<std::string> modules;
     llvm::Optional<std::string> host;
     std::string name;
-    llvm::SmallVector<std::int64_t, 8> kinds;
+    llvm::SmallVector<std::int64_t> kinds;
     NameKind nk = NameKind::NOT_UNIQUED;
     for (std::size_t i = 2, end{uniq.size()}; i != end;) {
       switch (uniq[i]) {
       case 'B':
         nk = NameKind::COMMON;
         name = readName(uniq, i, i + 1, end);
         break;
       case 'C':

flang/lib/Optimizer/Support/KindMapping.cpp

 static constexpr const char *kwDouble = "Double";
 static constexpr const char *kwX86FP80 = "X86_FP80";
 static constexpr const char *kwFP128 = "FP128";
 static constexpr const char *kwPPCFP128 = "PPC_FP128";
 
 /// Integral types default to the kind value being the size of the value in
 /// bytes. The default is to scale from bytes to bits.
 static Bitsize defaultScalingKind(KindTy kind) {
-  const unsigned BITS_IN_BYTE = 8;
-  return kind * BITS_IN_BYTE;
+  const unsigned bitsInByte = 8;
+  return kind * bitsInByte;
 }
 
 /// Floating-point types default to the kind value being the size of the value
 /// in bytes. The default is to translate kinds of 2, 3, 4, 8, 10, and 16 to a
 /// valid llvm::Type::TypeID value. Otherwise, the default is FloatTyID.
 static LLVMTypeID defaultRealKind(KindTy kind) {
   switch (kind) {
   case 2: