[flang] Remove some auto

[clementval]

Summary

This patch replaces some auto with proper type. This was done in fir-dev
but not upstreamed yet.

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

flang/lib/Lower/IO.cpp

inline int64_t getLength(mlir::Type argTy) {
   return argTy.cast<fir::SequenceType>().getShape()[0];
 }
 
 /// Get (or generate) the MLIR FuncOp for a given IO runtime function.
 template <typename E>
 static mlir::func::FuncOp getIORuntimeFunc(mlir::Location loc,
                                            fir::FirOpBuilder &builder) {
   llvm::StringRef name = getName<E>();
-  auto func = builder.getNamedFunction(name);
+  mlir::func::FuncOp func = builder.getNamedFunction(name);
   if (func)
     return func;
   auto funTy = getTypeModel<E>()(builder.getContext());
   func = builder.createFunction(loc, name, funTy);
   func->setAttr("fir.runtime", builder.getUnitAttr());
   func->setAttr("fir.io", builder.getUnitAttr());
   return func;
 }
 
 /// Generate calls to end an IO statement.  Return the IOSTAT value, if any.
 /// It is the caller's responsibility to generate branches on that value.
 static mlir::Value genEndIO(Fortran::lower::AbstractConverter &converter,
                             mlir::Location loc, mlir::Value cookie,
                             ConditionSpecInfo &csi,
                             Fortran::lower::StatementContext &stmtCtx) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   if (csi.ioMsg) {
-    auto getIoMsg = getIORuntimeFunc<mkIOKey(GetIoMsg)>(loc, builder);
+    mlir::func::FuncOp getIoMsg =
+        getIORuntimeFunc<mkIOKey(GetIoMsg)>(loc, builder);
     builder.create<fir::CallOp>(
         loc, getIoMsg,
         mlir::ValueRange{
             cookie,
             builder.createConvert(loc, getIoMsg.getFunctionType().getInput(1),
                                   fir::getBase(*csi.ioMsg)),
             builder.createConvert(loc, getIoMsg.getFunctionType().getInput(2),
                                   fir::getLen(*csi.ioMsg))});
   }
-  auto endIoStatement = getIORuntimeFunc<mkIOKey(EndIoStatement)>(loc, builder);
+  mlir::func::FuncOp endIoStatement =
+      getIORuntimeFunc<mkIOKey(EndIoStatement)>(loc, builder);
   auto call = builder.create<fir::CallOp>(loc, endIoStatement,
                                           mlir::ValueRange{cookie});
   mlir::Value iostat = call.getResult(0);
   if (csi.bigUnitIfOp) {
     stmtCtx.finalize(/*popScope=*/true);
     builder.create<fir::ResultOp>(loc, iostat);
     builder.setInsertionPointAfter(csi.bigUnitIfOp);
     iostat = csi.bigUnitIfOp.getResult(0);
for (const Fortran::parser::OutputItem &item : items) {
     mlir::Location loc = converter.genLocation(pExpr.source);
     makeNextConditionalOn(builder, loc, checkResult, ok, inLoop);
     Fortran::lower::StatementContext stmtCtx;
 
     const auto *expr = Fortran::semantics::GetExpr(pExpr);
     if (!expr)
       fir::emitFatalError(loc, "internal error: could not get evaluate::Expr");
     mlir::Type itemTy = converter.genType(*expr);
-    auto outputFunc = getOutputFunc(loc, builder, itemTy, isFormatted);
+    mlir::func::FuncOp outputFunc =
+        getOutputFunc(loc, builder, itemTy, isFormatted);
     mlir::Type argType = outputFunc.getFunctionType().getInput(1);
     assert((isFormatted || argType.isa<fir::BoxType>()) &&
            "expect descriptor for unformatted IO runtime");
     llvm::SmallVector<mlir::Value> outputFuncArgs = {cookie};
     fir::factory::CharacterExprHelper helper{builder, loc};
     if (argType.isa<fir::BoxType>()) {
       mlir::Value box = fir::getBase(converter.genExprBox(loc, *expr, stmtCtx));
       outputFuncArgs.push_back(builder.createConvert(loc, argType, box));
for (const Fortran::parser::InputItem &item : items) {
     makeNextConditionalOn(builder, loc, checkResult, ok, inLoop);
     Fortran::lower::StatementContext stmtCtx;
     const auto *expr = Fortran::semantics::GetExpr(pVar);
     if (!expr)
       fir::emitFatalError(loc, "internal error: could not get evaluate::Expr");
     if (Fortran::evaluate::HasVectorSubscript(*expr)) {
       auto vectorSubscriptBox =
           Fortran::lower::genVectorSubscriptBox(loc, converter, stmtCtx, *expr);
-      auto inputFunc = getInputFunc(
+      mlir::func::FuncOp inputFunc = getInputFunc(
           loc, builder, vectorSubscriptBox.getElementType(), isFormatted);
       const bool mustBox =
           inputFunc.getFunctionType().getInput(1).isa<fir::BoxType>();
       if (!checkResult) {
         auto elementalGenerator = [&](const fir::ExtendedValue &element) {
           createIoRuntimeCallForItem(loc, builder, inputFunc, cookie,
                                      mustBox ? builder.createBox(loc, element)
                                              : element);
if (Fortran::evaluate::HasVectorSubscript(*expr)) {
         if (!ok)
           ok = builder.createBool(loc, true);
         ok = vectorSubscriptBox.loopOverElementsWhile(builder, loc,
                                                       elementalGenerator, ok);
       }
       continue;
     }
     mlir::Type itemTy = converter.genType(*expr);
-    auto inputFunc = getInputFunc(loc, builder, itemTy, isFormatted);
+    mlir::func::FuncOp inputFunc =
+        getInputFunc(loc, builder, itemTy, isFormatted);
     auto itemExv = inputFunc.getFunctionType().getInput(1).isa<fir::BoxType>()
                        ? converter.genExprBox(loc, *expr, stmtCtx)
                        : converter.genExprAddr(loc, expr, stmtCtx);
     ok = createIoRuntimeCallForItem(loc, builder, inputFunc, cookie, itemExv);
   }
 }
 
 /// Generate an io-implied-do loop.

 
 /// Generic to build an integral argument to the runtime.
 template <typename A, typename B>
 mlir::Value genIntIOOption(Fortran::lower::AbstractConverter &converter,
                            mlir::Location loc, mlir::Value cookie,
                            const B &spec) {
   Fortran::lower::StatementContext localStatementCtx;
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
-  auto ioFunc = getIORuntimeFunc<A>(loc, builder);
+  mlir::func::FuncOp ioFunc = getIORuntimeFunc<A>(loc, builder);
   mlir::FunctionType ioFuncTy = ioFunc.getFunctionType();
   mlir::Value expr = fir::getBase(converter.genExprValue(
       loc, Fortran::semantics::GetExpr(spec.v), localStatementCtx));
   mlir::Value val = builder.createConvert(loc, ioFuncTy.getInput(1), expr);
   llvm::SmallVector<mlir::Value> ioArgs = {cookie, val};
   return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
 }
 
 /// Generic to build a string argument to the runtime. This passes a CHARACTER
 /// as a pointer to the buffer and a LEN parameter.
 template <typename A, typename B>
 mlir::Value genCharIOOption(Fortran::lower::AbstractConverter &converter,
                             mlir::Location loc, mlir::Value cookie,
                             const B &spec) {
   Fortran::lower::StatementContext localStatementCtx;
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
-  auto ioFunc = getIORuntimeFunc<A>(loc, builder);
+  mlir::func::FuncOp ioFunc = getIORuntimeFunc<A>(loc, builder);
   mlir::FunctionType ioFuncTy = ioFunc.getFunctionType();
   std::tuple<mlir::Value, mlir::Value, mlir::Value> tup =
       lowerStringLit(converter, loc, localStatementCtx, spec,
                      ioFuncTy.getInput(1), ioFuncTy.getInput(2));
   llvm::SmallVector<mlir::Value> ioArgs = {cookie, std::get<0>(tup),
                                            std::get<1>(tup)};
   return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
 }

 
 template <>
 mlir::Value genIOOption<Fortran::parser::FileNameExpr>(
     Fortran::lower::AbstractConverter &converter, mlir::Location loc,
     mlir::Value cookie, const Fortran::parser::FileNameExpr &spec) {
   Fortran::lower::StatementContext localStatementCtx;
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   // has an extra KIND argument
-  auto ioFunc = getIORuntimeFunc<mkIOKey(SetFile)>(loc, builder);
+  mlir::func::FuncOp ioFunc = getIORuntimeFunc<mkIOKey(SetFile)>(loc, builder);
   mlir::FunctionType ioFuncTy = ioFunc.getFunctionType();
   std::tuple<mlir::Value, mlir::Value, mlir::Value> tup =
       lowerStringLit(converter, loc, localStatementCtx, spec,
                      ioFuncTy.getInput(1), ioFuncTy.getInput(2));
   llvm::SmallVector<mlir::Value> ioArgs{cookie, std::get<0>(tup),
                                         std::get<1>(tup)};
   return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
 }
static void genIOReadSize(Fortran::lower::AbstractConverter &converter,
   // needs to be filled even if some error condition (end-of-file...) was met
   // during the input statement (in which case the runtime may return zero for
   // the size read).
   for (const auto &spec : specList)
     if (const auto *size =
             std::get_if<Fortran::parser::IoControlSpec::Size>(&spec.u)) {
 
       fir::FirOpBuilder &builder = converter.getFirOpBuilder();
-      auto ioFunc = getIORuntimeFunc<mkIOKey(GetSize)>(loc, builder);
+      mlir::func::FuncOp ioFunc =
+          getIORuntimeFunc<mkIOKey(GetSize)>(loc, builder);
       auto sizeValue =
           builder.create<fir::CallOp>(loc, ioFunc, mlir::ValueRange{cookie})
               .getResult(0);
       Fortran::lower::StatementContext localStatementCtx;
       fir::ExtendedValue var = converter.genExprAddr(
           loc, Fortran::semantics::GetExpr(size->v), localStatementCtx);
       mlir::Value varAddr = fir::getBase(var);
       mlir::Type varType = fir::unwrapPassByRefType(varAddr.getType());

 template <typename A>
 static void
 genConditionHandlerCall(Fortran::lower::AbstractConverter &converter,
                         mlir::Location loc, mlir::Value cookie,
                         const A &specList, ConditionSpecInfo &csi) {
   if (!csi.hasAnyConditionSpec())
     return;
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
-  auto enableHandlers = getIORuntimeFunc<mkIOKey(EnableHandlers)>(loc, builder);
+  mlir::func::FuncOp enableHandlers =
+      getIORuntimeFunc<mkIOKey(EnableHandlers)>(loc, builder);
   mlir::Type boolType = enableHandlers.getFunctionType().getInput(1);
   auto boolValue = [&](bool specifierIsPresent) {
     return builder.create<mlir::arith::ConstantOp>(
         loc, builder.getIntegerAttr(boolType, specifierIsPresent));
   };
   llvm::SmallVector<mlir::Value> ioArgs = {cookie,
                                            boolValue(csi.ioStatExpr != nullptr),
                                            boolValue(csi.hasErr),
static mlir::Value genIOUnitNumber(Fortran::lower::AbstractConverter &converter,
   auto rawUnit = fir::getBase(converter.genExprValue(loc, iounit, stmtCtx));
   unsigned rawUnitWidth =
       rawUnit.getType().cast<mlir::IntegerType>().getWidth();
   unsigned runtimeArgWidth = ty.cast<mlir::IntegerType>().getWidth();
   // The IO runtime supports `int` unit numbers, if the unit number may
   // overflow when passed to the IO runtime, check that the unit number is
   // in range before calling the BeginXXX.
   if (rawUnitWidth > runtimeArgWidth) {
-    auto check =
+    mlir::func::FuncOp check =
         rawUnitWidth <= 64
             ? getIORuntimeFunc<mkIOKey(CheckUnitNumberInRange64)>(loc, builder)
             : getIORuntimeFunc<mkIOKey(CheckUnitNumberInRange128)>(loc,
                                                                    builder);
     mlir::FunctionType funcTy = check.getFunctionType();
     llvm::SmallVector<mlir::Value> args;
     args.push_back(builder.createConvert(loc, funcTy.getInput(0), rawUnit));
     args.push_back(builder.createBool(loc, csi.hasErrorConditionSpec()));

 
 template <typename K, typename S>
 static mlir::Value genBasicIOStmt(Fortran::lower::AbstractConverter &converter,
                                   const S &stmt) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   Fortran::lower::StatementContext stmtCtx;
   mlir::Location loc = converter.getCurrentLocation();
   ConditionSpecInfo csi = lowerErrorSpec(converter, loc, stmt.v);
-  auto beginFunc = getIORuntimeFunc<K>(loc, builder);
+  mlir::func::FuncOp beginFunc = getIORuntimeFunc<K>(loc, builder);
   mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
   mlir::Value unit = genIOUnitNumber(
       converter, loc, getExpr<Fortran::parser::FileUnitNumber>(stmt),
       beginFuncTy.getInput(0), csi, stmtCtx);
   mlir::Value un = builder.createConvert(loc, beginFuncTy.getInput(0), unit);
   mlir::Value file = locToFilename(converter, loc, beginFuncTy.getInput(1));
   mlir::Value line = locToLineNo(converter, loc, beginFuncTy.getInput(2));
   auto call = builder.create<fir::CallOp>(loc, beginFunc,

 genNewunitSpec(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
                mlir::Value cookie,
                const std::list<Fortran::parser::ConnectSpec> &specList) {
   for (const auto &spec : specList)
     if (auto *newunit =
             std::get_if<Fortran::parser::ConnectSpec::Newunit>(&spec.u)) {
       Fortran::lower::StatementContext stmtCtx;
       fir::FirOpBuilder &builder = converter.getFirOpBuilder();
-      auto ioFunc = getIORuntimeFunc<mkIOKey(GetNewUnit)>(loc, builder);
+      mlir::func::FuncOp ioFunc =
+          getIORuntimeFunc<mkIOKey(GetNewUnit)>(loc, builder);
       mlir::FunctionType ioFuncTy = ioFunc.getFunctionType();
       const auto *var = Fortran::semantics::GetExpr(newunit->v);
       mlir::Value addr = builder.createConvert(
           loc, ioFuncTy.getInput(1),
           fir::getBase(converter.genExprAddr(loc, var, stmtCtx)));
       auto kind = builder.createIntegerConstant(loc, ioFuncTy.getInput(2),
                                                 var->GetType().value().kind());
       llvm::SmallVector<mlir::Value> ioArgs = {cookie, addr, kind};

 mlir::Value
 Fortran::lower::genWaitStatement(Fortran::lower::AbstractConverter &converter,
                                  const Fortran::parser::WaitStmt &stmt) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   Fortran::lower::StatementContext stmtCtx;
   mlir::Location loc = converter.getCurrentLocation();
   ConditionSpecInfo csi = lowerErrorSpec(converter, loc, stmt.v);
   bool hasId = hasSpec<Fortran::parser::IdExpr>(stmt);
-  auto beginFunc = hasId
-                       ? getIORuntimeFunc<mkIOKey(BeginWait)>(loc, builder)
-                       : getIORuntimeFunc<mkIOKey(BeginWaitAll)>(loc, builder);
+  mlir::func::FuncOp beginFunc =
+      hasId ? getIORuntimeFunc<mkIOKey(BeginWait)>(loc, builder)
   mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
   mlir::Value unit = genIOUnitNumber(
       converter, loc, getExpr<Fortran::parser::FileUnitNumber>(stmt),
       beginFuncTy.getInput(0), csi, stmtCtx);
   llvm::SmallVector<mlir::Value> args{unit};
   if (hasId) {
     mlir::Value id = fir::getBase(converter.genExprValue(
         loc, getExpr<Fortran::parser::IdExpr>(stmt), stmtCtx));
genDataTransferStmt(Fortran::lower::AbstractConverter &converter,
 
   // Generate an EnableHandlers call and remaining specifier calls.
   ConditionSpecInfo csi;
   if constexpr (hasIOCtrl) {
     csi = lowerErrorSpec(converter, loc, stmt.controls);
   }
 
   // Generate the begin data transfer function call.
-  auto ioFunc = getBeginDataTransferFunc<isInput>(loc, builder, isFormatted,
-                                                  isList || isNml, isInternal,
-                                                  isInternalWithDesc, isAsync);
+  mlir::func::FuncOp ioFunc = getBeginDataTransferFunc<isInput>(
+      loc, builder, isFormatted, isList || isNml, isInternal,
   llvm::SmallVector<mlir::Value> ioArgs;
   genBeginDataTransferCallArgs<hasIOCtrl>(
       ioArgs, converter, loc, stmt, ioFunc.getFunctionType(), isFormatted,
       isList || isNml, isInternal, isAsync, descRef, csi, stmtCtx);
   mlir::Value cookie =
       builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
 
   auto insertPt = builder.saveInsertionPoint();
mlir::Value genInquireSpec<Fortran::parser::InquireSpec::CharVar>(
     mlir::Value cookie, mlir::Value idExpr,
     const Fortran::parser::InquireSpec::CharVar &var,
     Fortran::lower::StatementContext &stmtCtx) {
   // IOMSG is handled with exception conditions
   if (std::get<Fortran::parser::InquireSpec::CharVar::Kind>(var.t) ==
       Fortran::parser::InquireSpec::CharVar::Kind::Iomsg)
     return {};
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
-  auto specFunc = getIORuntimeFunc<mkIOKey(InquireCharacter)>(loc, builder);
+  mlir::func::FuncOp specFunc =
+      getIORuntimeFunc<mkIOKey(InquireCharacter)>(loc, builder);
   mlir::FunctionType specFuncTy = specFunc.getFunctionType();
   const auto *varExpr = Fortran::semantics::GetExpr(
       std::get<Fortran::parser::ScalarDefaultCharVariable>(var.t));
   fir::ExtendedValue str = converter.genExprAddr(loc, varExpr, stmtCtx);
   llvm::SmallVector<mlir::Value> args = {
       builder.createConvert(loc, specFuncTy.getInput(0), cookie),
       builder.createIntegerConstant(
           loc, specFuncTy.getInput(1),
mlir::Value genInquireSpec<Fortran::parser::InquireSpec::IntVar>(
     mlir::Value cookie, mlir::Value idExpr,
     const Fortran::parser::InquireSpec::IntVar &var,
     Fortran::lower::StatementContext &stmtCtx) {
   // IOSTAT is handled with exception conditions
   if (std::get<Fortran::parser::InquireSpec::IntVar::Kind>(var.t) ==
       Fortran::parser::InquireSpec::IntVar::Kind::Iostat)
     return {};
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
-  auto specFunc = getIORuntimeFunc<mkIOKey(InquireInteger64)>(loc, builder);
+  mlir::func::FuncOp specFunc =
+      getIORuntimeFunc<mkIOKey(InquireInteger64)>(loc, builder);
   mlir::FunctionType specFuncTy = specFunc.getFunctionType();
   const auto *varExpr = Fortran::semantics::GetExpr(
       std::get<Fortran::parser::ScalarIntVariable>(var.t));
   mlir::Value addr = fir::getBase(converter.genExprAddr(loc, varExpr, stmtCtx));
   mlir::Type eleTy = fir::dyn_cast_ptrEleTy(addr.getType());
   if (!eleTy)
     fir::emitFatalError(loc,
                         "internal error: expected a memory reference type");
mlir::Value genInquireSpec<Fortran::parser::InquireSpec::LogVar>(
     mlir::Value cookie, mlir::Value idExpr,
     const Fortran::parser::InquireSpec::LogVar &var,
     Fortran::lower::StatementContext &stmtCtx) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   auto logVarKind = std::get<Fortran::parser::InquireSpec::LogVar::Kind>(var.t);
   bool pendId =
       idExpr &&
       logVarKind == Fortran::parser::InquireSpec::LogVar::Kind::Pending;
-  auto specFunc =
+  mlir::func::FuncOp specFunc =
       pendId ? getIORuntimeFunc<mkIOKey(InquirePendingId)>(loc, builder)
              : getIORuntimeFunc<mkIOKey(InquireLogical)>(loc, builder);
   mlir::FunctionType specFuncTy = specFunc.getFunctionType();
   mlir::Value addr = fir::getBase(converter.genExprAddr(
       loc,
       Fortran::semantics::GetExpr(
           std::get<Fortran::parser::Scalar<
               Fortran::parser::Logical<Fortran::parser::Variable>>>(var.t)),

flang/lib/Lower/Mangler.cpp

if (scope.kind() == Fortran::semantics::Scope::Kind::MainProgram)
     // (technically illegal, but all compilers are able to compile and link
     // properly these programs).
     return llvm::StringRef("");
   return {};
 }
 
 static const Fortran::semantics::Symbol *
 findInterfaceIfSeperateMP(const Fortran::semantics::Symbol &symbol) {
-  const auto &scope = symbol.owner();
+  const Fortran::semantics::Scope &scope = symbol.owner();
   if (symbol.attrs().test(Fortran::semantics::Attr::MODULE) &&
       scope.IsSubmodule()) {
     // FIXME symbol from MpSubprogramStmt do not seem to have
     // Attr::MODULE set.
-    const auto *iface = scope.parent().FindSymbol(symbol.name());
+    const Fortran::semantics::Symbol *iface =
+        scope.parent().FindSymbol(symbol.name());
     assert(iface && "Separate module procedure must be declared");
     return iface;
   }
   return nullptr;
 }
 
 // Mangle the name of `symbol` to make it unique within FIR's symbol table using
 // the FIR name mangler, `mangler`
return std::visit(
             // Mangle external procedure without any scope prefix.
             if (!keepExternalInScope &&
                 Fortran::semantics::IsExternal(ultimateSymbol))
               return fir::NameUniquer::doProcedure(llvm::None, llvm::None,
                                                    symbolName);
             // Separate module subprograms must be mangled according to the
             // scope where they were declared (the symbol we have is the
             // definition).
-            const auto *interface = &ultimateSymbol;
+            const Fortran::semantics::Symbol *interface = &ultimateSymbol;
             if (const auto *mpIface = findInterfaceIfSeperateMP(ultimateSymbol))
               interface = mpIface;
-            auto modNames = moduleNames(*interface);
+            llvm::SmallVector<llvm::StringRef> modNames =
+                moduleNames(*interface);
             return fir::NameUniquer::doProcedure(modNames, hostName(*interface),
                                                  symbolName);
           },
           [&](const Fortran::semantics::ProcEntityDetails &) {
             // Mangle procedure pointers and dummy procedures as variables
             if (Fortran::semantics::IsPointer(ultimateSymbol) ||
                 Fortran::semantics::IsDummy(ultimateSymbol))
               return fir::NameUniquer::doVariable(moduleNames(ultimateSymbol),
                                                   hostName(ultimateSymbol),
                                                   symbolName);
             // Otherwise, this is an external procedure, even if it does not
             // have an explicit EXTERNAL attribute. Mangle it without any
             // prefix.
             return fir::NameUniquer::doProcedure(llvm::None, llvm::None,
                                                  symbolName);
           },
           [&](const Fortran::semantics::ObjectEntityDetails &) {
-            auto modNames = moduleNames(ultimateSymbol);
-            auto optHost = hostName(ultimateSymbol);
+            llvm::SmallVector<llvm::StringRef> modNames =
+                moduleNames(ultimateSymbol);
+            llvm::Optional<llvm::StringRef> optHost = hostName(ultimateSymbol);
             if (Fortran::semantics::IsNamedConstant(ultimateSymbol))
               return fir::NameUniquer::doConstant(modNames, optHost,
                                                   symbolName);
             return fir::NameUniquer::doVariable(modNames, optHost, symbolName);
           },
           [&](const Fortran::semantics::NamelistDetails &) {
-            auto modNames = moduleNames(ultimateSymbol);
-            auto optHost = hostName(ultimateSymbol);
+            llvm::SmallVector<llvm::StringRef> modNames =
+                moduleNames(ultimateSymbol);
+            llvm::Optional<llvm::StringRef> optHost = hostName(ultimateSymbol);
             return fir::NameUniquer::doNamelistGroup(modNames, optHost,
                                                      symbolName);
           },
           [&](const Fortran::semantics::CommonBlockDetails &) {
             return fir::NameUniquer::doCommonBlock(symbolName);
           },
           [&](const Fortran::semantics::DerivedTypeDetails &) -> std::string {
             // Derived type mangling must used mangleName(DerivedTypeSpec&) so
             // that kind type parameter values can be mangled.
             llvm::report_fatal_error(
                 "only derived type instances can be mangled");
           },
           [](const auto &) -> std::string { TODO_NOLOC("symbol mangling"); },
       },
       ultimateSymbol.details());
 }
 
 std::string Fortran::lower::mangle::mangleName(
     const Fortran::semantics::DerivedTypeSpec &derivedType) {
   // Resolve host and module association before mangling
-  const auto &ultimateSymbol = derivedType.typeSymbol().GetUltimate();
-  auto symbolName = toStringRef(ultimateSymbol.name());
-  auto modNames = moduleNames(ultimateSymbol);
-  auto optHost = hostName(ultimateSymbol);
+  const Fortran::semantics::Symbol &ultimateSymbol =
+      derivedType.typeSymbol().GetUltimate();
+  llvm::StringRef symbolName = toStringRef(ultimateSymbol.name());
+  llvm::SmallVector<llvm::StringRef> modNames = moduleNames(ultimateSymbol);
+  llvm::Optional<llvm::StringRef> optHost = hostName(ultimateSymbol);
   llvm::SmallVector<std::int64_t> kinds;
   for (const auto &param :
        Fortran::semantics::OrderParameterDeclarations(ultimateSymbol)) {
     const auto &paramDetails =
         param->get<Fortran::semantics::TypeParamDetails>();
     if (paramDetails.attr() == Fortran::common::TypeParamAttr::Kind) {
-      const auto *paramValue = derivedType.FindParameter(param->name());
+      const Fortran::semantics::ParamValue *paramValue =
+          derivedType.FindParameter(param->name());
       assert(paramValue && "derived type kind parameter value not found");
-      auto paramExpr = paramValue->GetExplicit();
+      const Fortran::semantics::MaybeIntExpr paramExpr =
+          paramValue->GetExplicit();
       assert(paramExpr && "derived type kind param not explicit");
-      auto init = Fortran::evaluate::ToInt64(paramValue->GetExplicit());
+      std::optional<int64_t> init =
+          Fortran::evaluate::ToInt64(paramValue->GetExplicit());
       assert(init && "derived type kind param is not constant");
       kinds.emplace_back(*init);
     }
   }
   return fir::NameUniquer::doType(modNames, optHost, symbolName, kinds);
 }
 
 std::string Fortran::lower::mangle::demangleName(llvm::StringRef name) {

 }
 
 std::string fir::mangleIntrinsicProcedure(llvm::StringRef intrinsic,
                                           mlir::FunctionType funTy) {
   std::string name = "fir.";
   name.append(intrinsic.str()).append(".");
   assert(funTy.getNumResults() == 1 && "only function mangling supported");
   name.append(typeToString(funTy.getResult(0)));
-  auto e = funTy.getNumInputs();
+  unsigned e = funTy.getNumInputs();
   for (decltype(e) i = 0; i < e; ++i)
     name.append(".").append(typeToString(funTy.getInput(i)));
   return name;
 }