Skip to content

Commit eb7dd2e

Browse files
clementvalclementval
authored
Review usage of auto in Lower/HostAssociations.cpp (#1309)
1 parent 4d61bbc commit eb7dd2e

File tree

1 file changed

+54
-52
lines changed

1 file changed

+54
-52
lines changed

‎flang/lib/Lower/HostAssociations.cpp

Lines changed: 54 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -135,11 +135,11 @@ class CapturedSimpleScalars : public CapturedSymbols<CapturedSimpleScalars> {
135135
static void instantiateHostTuple(const InstantiateHostTuple &args,
136136
Fortran::lower::AbstractConverter &converter,
137137
const Fortran::semantics::Symbol &) {
138-
auto &builder = converter.getFirOpBuilder();
139-
auto typeInTuple = fir::dyn_cast_ptrEleTy(args.addrInTuple.getType());
138+
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
139+
mlir::Type typeInTuple = fir::dyn_cast_ptrEleTy(args.addrInTuple.getType());
140140
assert(typeInTuple && "addrInTuple must be an address");
141-
auto castBox = builder.createConvert(args.loc, typeInTuple,
142-
fir::getBase(args.hostValue));
141+
mlir::Value castBox = builder.createConvert(args.loc, typeInTuple,
142+
fir::getBase(args.hostValue));
143143
builder.create<fir::StoreOp>(args.loc, castBox, args.addrInTuple);
144144
}
145145

@@ -166,11 +166,11 @@ class CapturedProcedure : public CapturedSymbols<CapturedProcedure> {
166166
static void instantiateHostTuple(const InstantiateHostTuple &args,
167167
Fortran::lower::AbstractConverter &converter,
168168
const Fortran::semantics::Symbol &) {
169-
auto &builder = converter.getFirOpBuilder();
170-
auto typeInTuple = fir::dyn_cast_ptrEleTy(args.addrInTuple.getType());
169+
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
170+
mlir::Type typeInTuple = fir::dyn_cast_ptrEleTy(args.addrInTuple.getType());
171171
assert(typeInTuple && "addrInTuple must be an address");
172-
auto castBox = builder.createConvert(args.loc, typeInTuple,
173-
fir::getBase(args.hostValue));
172+
mlir::Value castBox = builder.createConvert(args.loc, typeInTuple,
173+
fir::getBase(args.hostValue));
174174
builder.create<fir::StoreOp>(args.loc, castBox, args.addrInTuple);
175175
}
176176

@@ -193,18 +193,19 @@ class CapturedCharacterScalars
193193

194194
static mlir::Type getType(Fortran::lower::AbstractConverter &converter,
195195
const Fortran::semantics::Symbol &sym) {
196-
auto kind = converter.genType(sym).cast<fir::CharacterType>().getFKind();
196+
fir::KindTy kind =
197+
converter.genType(sym).cast<fir::CharacterType>().getFKind();
197198
return fir::BoxCharType::get(&converter.getMLIRContext(), kind);
198199
}
199200

200201
static void instantiateHostTuple(const InstantiateHostTuple &args,
201202
Fortran::lower::AbstractConverter &converter,
202203
const Fortran::semantics::Symbol &) {
203-
auto *charBox = args.hostValue.getCharBox();
204+
const fir::CharBoxValue *charBox = args.hostValue.getCharBox();
204205
assert(charBox && "host value must be a fir::CharBoxValue");
205-
auto &builder = converter.getFirOpBuilder();
206-
auto boxchar = fir::factory::CharacterExprHelper(builder, args.loc)
207-
.createEmbox(*charBox);
206+
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
207+
mlir::Value boxchar = fir::factory::CharacterExprHelper(builder, args.loc)
208+
.createEmbox(*charBox);
208209
builder.create<fir::StoreOp>(args.loc, boxchar, args.addrInTuple);
209210
}
210211

@@ -214,7 +215,8 @@ class CapturedCharacterScalars
214215
const Fortran::lower::BoxAnalyzer &) {
215216
fir::factory::CharacterExprHelper charHelp(converter.getFirOpBuilder(),
216217
args.loc);
217-
auto unboxchar = charHelp.createUnboxChar(args.valueInTuple);
218+
std::pair<mlir::Value, mlir::Value> unboxchar =
219+
charHelp.createUnboxChar(args.valueInTuple);
218220
args.symMap.addCharSymbol(sym, unboxchar.first, unboxchar.second);
219221
}
220222
};
@@ -243,28 +245,28 @@ class CapturedAllocatableAndPointer
243245
const Fortran::semantics::Symbol &) {
244246
assert(args.hostValue.getBoxOf<fir::MutableBoxValue>() &&
245247
"host value must be a fir::MutableBoxValue");
246-
auto &builder = converter.getFirOpBuilder();
247-
auto typeInTuple = fir::dyn_cast_ptrEleTy(args.addrInTuple.getType());
248+
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
249+
mlir::Type typeInTuple = fir::dyn_cast_ptrEleTy(args.addrInTuple.getType());
248250
assert(typeInTuple && "addrInTuple must be an address");
249-
auto castBox = builder.createConvert(args.loc, typeInTuple,
250-
fir::getBase(args.hostValue));
251+
mlir::Value castBox = builder.createConvert(args.loc, typeInTuple,
252+
fir::getBase(args.hostValue));
251253
builder.create<fir::StoreOp>(args.loc, castBox, args.addrInTuple);
252254
}
253255
static void getFromTuple(const GetFromTuple &args,
254256
Fortran::lower::AbstractConverter &converter,
255257
const Fortran::semantics::Symbol &sym,
256258
const Fortran::lower::BoxAnalyzer &ba) {
257-
auto &builder = converter.getFirOpBuilder();
258-
auto loc = args.loc;
259+
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
260+
mlir::Location loc = args.loc;
259261
// Non deferred type parameters impact the semantics of some statements
260262
// where allocatables/pointer can appear. For instance, assignment to a
261263
// scalar character allocatable with has a different semantics in F2003 and
262264
// later if the length is non deferred vs when it is deferred. So it is
263265
// important to keep track of the non deferred parameters here.
264266
llvm::SmallVector<mlir::Value> nonDeferredLenParams;
265267
if (ba.isChar()) {
266-
auto idxTy = builder.getIndexType();
267-
if (auto len = ba.getCharLenConst()) {
268+
mlir::IndexType idxTy = builder.getIndexType();
269+
if (llvm::Optional<int64_t> len = ba.getCharLenConst()) {
268270
nonDeferredLenParams.push_back(
269271
builder.createIntegerConstant(loc, idxTy, *len));
270272
} else if (Fortran::semantics::IsAssumedLengthCharacter(sym) ||
@@ -284,7 +286,7 @@ class CapturedAllocatableAndPointer
284286
// it's fine to use undefOp in this case.
285287
auto isPresent = builder.create<fir::IsPresentOp>(
286288
loc, builder.getI1Type(), fir::getBase(args.valueInTuple));
287-
auto len =
289+
mlir::Value len =
288290
builder.genIfOp(loc, {idxTy}, isPresent, true)
289291
.genThen([&]() {
290292
builder.create<fir::ResultOp>(loc, readLength());
@@ -321,16 +323,16 @@ class CapturedArrays : public CapturedSymbols<CapturedArrays> {
321323
public:
322324
static mlir::Type getType(Fortran::lower::AbstractConverter &converter,
323325
const Fortran::semantics::Symbol &sym) {
324-
auto type = converter.genType(sym);
326+
mlir::Type type = converter.genType(sym);
325327
assert(type.isa<fir::SequenceType>() && "must be a sequence type");
326328
return fir::BoxType::get(type);
327329
}
328330

329331
static void instantiateHostTuple(const InstantiateHostTuple &args,
330332
Fortran::lower::AbstractConverter &converter,
331333
const Fortran::semantics::Symbol &sym) {
332-
auto &builder = converter.getFirOpBuilder();
333-
auto loc = args.loc;
334+
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
335+
mlir::Location loc = args.loc;
334336
fir::MutableBoxValue boxInTuple(args.addrInTuple, {}, {});
335337
if (args.hostValue.getBoxOf<fir::BoxValue>() &&
336338
Fortran::semantics::IsOptional(sym)) {
@@ -362,21 +364,21 @@ class CapturedArrays : public CapturedSymbols<CapturedArrays> {
362364
Fortran::lower::AbstractConverter &converter,
363365
const Fortran::semantics::Symbol &sym,
364366
const Fortran::lower::BoxAnalyzer &ba) {
365-
auto &builder = converter.getFirOpBuilder();
366-
auto loc = args.loc;
367-
auto box = args.valueInTuple;
368-
auto idxTy = builder.getIndexType();
367+
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
368+
mlir::Location loc = args.loc;
369+
mlir::Value box = args.valueInTuple;
370+
mlir::IndexType idxTy = builder.getIndexType();
369371
llvm::SmallVector<mlir::Value> lbounds;
370372
if (!ba.lboundIsAllOnes()) {
371373
if (ba.isStaticArray()) {
372-
for (auto lb : ba.staticLBound())
374+
for (std::int64_t lb : ba.staticLBound())
373375
lbounds.emplace_back(builder.createIntegerConstant(loc, idxTy, lb));
374376
} else {
375377
// Cannot re-evaluate specification expressions here.
376378
// Operands values may have changed. Get value from fir.box
377379
const unsigned rank = sym.Rank();
378380
for (unsigned dim = 0; dim < rank; ++dim) {
379-
auto dimVal = builder.createIntegerConstant(loc, idxTy, dim);
381+
mlir::Value dimVal = builder.createIntegerConstant(loc, idxTy, dim);
380382
auto dims = builder.create<fir::BoxDimsOp>(loc, idxTy, idxTy, idxTy,
381383
box, dimVal);
382384
lbounds.emplace_back(dims.getResult(0));
@@ -397,7 +399,7 @@ class CapturedArrays : public CapturedSymbols<CapturedArrays> {
397399
if (Fortran::semantics::IsOptional(sym)) {
398400
auto boxTy = box.getType().cast<fir::BoxType>();
399401
auto addr = builder.create<fir::BoxAddrOp>(loc, boxTy.getEleTy(), box);
400-
auto isPresent = builder.genIsNotNull(loc, addr);
402+
mlir::Value isPresent = builder.genIsNotNull(loc, addr);
401403
auto absentBox = builder.create<fir::AbsentOp>(loc, boxTy);
402404
box = builder.create<mlir::SelectOp>(loc, isPresent, box, absentBox);
403405
}
@@ -417,7 +419,7 @@ class CapturedArrays : public CapturedSymbols<CapturedArrays> {
417419
sym.Rank() == 0 || Fortran::evaluate::IsSimplyContiguous(
418420
Fortran::evaluate::AsGenericExpr(sym).value(),
419421
converter.getFoldingContext());
420-
const auto *type = sym.GetType();
422+
const Fortran::semantics::DeclTypeSpec *type = sym.GetType();
421423
bool isPolymorphic = type && type->IsPolymorphic();
422424
return isScalarOrContiguous && !isPolymorphic &&
423425
!isDerivedWithLengthParameters(sym);
@@ -476,18 +478,18 @@ void Fortran::lower::HostAssociations::hostProcedureBindings(
476478
return;
477479

478480
// Create the tuple variable.
479-
auto tupTy = unwrapTupleTy(getArgumentType(converter));
480-
auto &builder = converter.getFirOpBuilder();
481-
auto loc = converter.genLocation();
481+
mlir::TupleType tupTy = unwrapTupleTy(getArgumentType(converter));
482+
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
483+
mlir::Location loc = converter.genLocation();
482484
auto hostTuple = builder.create<fir::AllocaOp>(loc, tupTy);
483-
auto offTy = builder.getIntegerType(32);
485+
mlir::IntegerType offTy = builder.getIntegerType(32);
484486

485487
// Walk the list of symbols and update the pointers in the tuple.
486488
for (auto s : llvm::enumerate(symbols)) {
487489
auto indexInTuple = s.index();
488-
auto off = builder.createIntegerConstant(loc, offTy, indexInTuple);
489-
auto varTy = tupTy.getType(indexInTuple);
490-
auto eleOff = genTupleCoor(builder, loc, varTy, hostTuple, off);
490+
mlir::Value off = builder.createIntegerConstant(loc, offTy, indexInTuple);
491+
mlir::Type varTy = tupTy.getType(indexInTuple);
492+
mlir::Value eleOff = genTupleCoor(builder, loc, varTy, hostTuple, off);
491493
InstantiateHostTuple instantiateHostTuple{
492494
symMap.lookupSymbol(s.value()).toExtendedValue(), eleOff, loc};
493495
walkCaptureCategories(instantiateHostTuple, converter, *s.value());
@@ -503,11 +505,11 @@ void Fortran::lower::HostAssociations::internalProcedureBindings(
503505
return;
504506

505507
// Find the argument with the tuple type. The argument ought to be appended.
506-
auto &builder = converter.getFirOpBuilder();
507-
auto argTy = getArgumentType(converter);
508-
auto tupTy = unwrapTupleTy(argTy);
509-
auto loc = converter.genLocation();
510-
auto func = builder.getFunction();
508+
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
509+
mlir::Type argTy = getArgumentType(converter);
510+
mlir::TupleType tupTy = unwrapTupleTy(argTy);
511+
mlir::Location loc = converter.genLocation();
512+
mlir::FuncOp func = builder.getFunction();
511513
mlir::Value tupleArg;
512514
for (auto [ty, arg] : llvm::reverse(
513515
llvm::zip(func.getType().getInputs(), func.front().getArguments())))
@@ -520,13 +522,13 @@ void Fortran::lower::HostAssociations::internalProcedureBindings(
520522

521523
converter.bindHostAssocTuple(tupleArg);
522524

523-
auto offTy = builder.getIntegerType(32);
525+
mlir::IntegerType offTy = builder.getIntegerType(32);
524526

525527
// Walk the list and add the bindings to the symbol table.
526528
for (auto s : llvm::enumerate(symbols)) {
527-
auto off = builder.createIntegerConstant(loc, offTy, s.index());
528-
auto varTy = tupTy.getType(s.index());
529-
auto eleOff = genTupleCoor(builder, loc, varTy, tupleArg, off);
529+
mlir::Value off = builder.createIntegerConstant(loc, offTy, s.index());
530+
mlir::Type varTy = tupTy.getType(s.index());
531+
mlir::Value eleOff = genTupleCoor(builder, loc, varTy, tupleArg, off);
530532
mlir::Value valueInTuple = builder.create<fir::LoadOp>(loc, eleOff);
531533
GetFromTuple getFromTuple{symMap, valueInTuple, loc};
532534
walkCaptureCategories(getFromTuple, converter, *s.value());
@@ -542,9 +544,9 @@ mlir::Type Fortran::lower::HostAssociations::getArgumentType(
542544

543545
// Walk the list of Symbols and create their types. Wrap them in a reference
544546
// to a tuple.
545-
auto *ctxt = &converter.getMLIRContext();
547+
mlir::MLIRContext *ctxt = &converter.getMLIRContext();
546548
llvm::SmallVector<mlir::Type> tupleTys;
547-
for (const auto *sym : symbols)
549+
for (const Fortran::semantics::Symbol *sym : symbols)
548550
tupleTys.emplace_back(
549551
walkCaptureCategories(GetTypeInTuple{}, converter, *sym));
550552
argType = fir::ReferenceType::get(mlir::TupleType::get(ctxt, tupleTys));

0 commit comments

Comments
 (0)