[flang][NFC] rename hlfir::FortranEntity into EntityWithAttributes

[jeanPerier]

Summary

This reflects the fact that Attributes will not always be visible when
looking at an HLFIR variable. The EntityWithAttributes class is used
to denote in the compiler code that the value at hand has visible
attributes. It is intended to be used in lowering so that the code
can query about operands attributes when generating code.

[clementval]

LGTM

flang/include/flang/Lower/ConvertExprToHLFIR.h

 } // namespace mlir
 
 namespace Fortran::lower {
 
 class AbstractConverter;
 class StatementContext;
 class SymMap;
 
-hlfir::FortranEntity convertExprToHLFIR(mlir::Location loc,
-                                        Fortran::lower::AbstractConverter &,
-                                        const Fortran::lower::SomeExpr &,
-                                        Fortran::lower::SymMap &,
-                                        Fortran::lower::StatementContext &);
+hlfir::EntityWithAttributes
+convertExprToHLFIR(mlir::Location loc, Fortran::lower::AbstractConverter &,
+                   const Fortran::lower::SomeExpr &, Fortran::lower::SymMap &,
 } // namespace Fortran::lower
 
 #endif // FORTRAN_LOWER_CONVERTEXPRTOHLFIR_H

flang/include/flang/Optimizer/Builder/HLFIRTools.h

 /// Is this a Fortran variable?
 /// Note that by "variable", it must be understood that the mlir::Value is
 /// a memory value of a storage that can be reason about as a Fortran object
 /// (its bounds, shape, and type parameters, if any, are retrievable).
 /// This does not imply that the mlir::Value points to a variable from the
 /// original source or can be legally defined: temporaries created to store
 /// expression values are considered to be variables, and so are PARAMETERs
 /// global constant address.
-inline bool isFortranVariable(mlir::Value value) {
+inline bool isFortranVariableWithAttributes(mlir::Value value) {
   return value.getDefiningOp<fir::FortranVariableOpInterface>();
 }
 
-/// Is this a Fortran variable or expression value?
-inline bool isFortranEntity(mlir::Value value) {
-  return isFortranValue(value) || isFortranVariable(value);
+/// Is this a Fortran expression value, or a Fortran variable for which the
+/// defining op carrying the Fortran attributes is visible?
+inline bool isFortranEntityWithAttributes(mlir::Value value) {
+  return isFortranValue(value) || isFortranVariableWithAttributes(value);
 }
 
 /// Wrapper over an mlir::Value that can be viewed as a Fortran entity.
 /// This provides some Fortran specific helpers as well as a guarantee
 /// in the compiler source that a certain mlir::Value must be a Fortran
-/// entity.
-class FortranEntity : public mlir::Value {
+/// entity, and if it is a variable, its defining operation carrying its
+/// Fortran attributes must be visible.
+class EntityWithAttributes : public mlir::Value {
 public:
-  explicit FortranEntity(mlir::Value value) : mlir::Value(value) {
-    assert(isFortranEntity(value) &&
+  explicit EntityWithAttributes(mlir::Value value) : mlir::Value(value) {
+    assert(isFortranEntityWithAttributes(value) &&
            "must be a value representing a Fortran value or variable");
   }
-  FortranEntity(fir::FortranVariableOpInterface variable)
+  EntityWithAttributes(fir::FortranVariableOpInterface variable)
       : mlir::Value(variable.getBase()) {}
   bool isValue() const { return isFortranValue(*this); }
   bool isVariable() const { return !isValue(); }
   fir::FortranVariableOpInterface getIfVariable() const {
     return this->getDefiningOp<fir::FortranVariableOpInterface>();
   }
   mlir::Value getBase() const { return *this; }
 };
 
-/// Functions to translate hlfir::FortranEntity to fir::ExtendedValue.
+/// Functions to translate hlfir::EntityWithAttributes to fir::ExtendedValue.
 /// For Fortran arrays, character, and derived type values, this require
 /// allocating a storage since these can only be represented in memory in FIR.
 /// In that case, a cleanup function is provided to generate the finalization
 /// code after the end of the fir::ExtendedValue use.
 using CleanupFunction = std::function<void()>;
 std::pair<fir::ExtendedValue, llvm::Optional<CleanupFunction>>
 translateToExtendedValue(mlir::Location loc, fir::FirOpBuilder &builder,
-                         FortranEntity entity);
+                         EntityWithAttributes entity);
 
 /// Function to translate FortranVariableOpInterface to fir::ExtendedValue.
 /// It does not generate any IR, and is a simple packaging operation.
 fir::ExtendedValue
 translateToExtendedValue(fir::FortranVariableOpInterface fortranVariable);
 
 /// Generate declaration for a fir::ExtendedValue in memory.
-FortranEntity genDeclare(mlir::Location loc, fir::FirOpBuilder &builder,
-                         const fir::ExtendedValue &exv, llvm::StringRef name,
+EntityWithAttributes genDeclare(mlir::Location loc, fir::FirOpBuilder &builder,
+                                const fir::ExtendedValue &exv,
+                                llvm::StringRef name,
                                 fir::FortranVariableFlagsAttr flags);
 
 } // namespace hlfir
 
 #endif // FORTRAN_OPTIMIZER_BUILDER_HLFIRTOOLS_H

flang/lib/Lower/Bridge.cpp

Fortran::lower::pft::FunctionLikeUnit &owningProc =
         *getEval().getOwningProcedure();
     auto iter = owningProc.labelEvaluationMap.find(label);
     if (iter == owningProc.labelEvaluationMap.end())
       return nullptr;
     return iter->second;
   }
 
   fir::ExtendedValue
-  translateToExtendedValue(mlir::Location loc, hlfir::FortranEntity entity,
+  translateToExtendedValue(mlir::Location loc,
+                           hlfir::EntityWithAttributes entity,
                            Fortran::lower::StatementContext &context) {
     auto [exv, exvCleanup] =
         hlfir::translateToExtendedValue(loc, getFirOpBuilder(), entity);
     if (exvCleanup)
       context.attachCleanup(*exvCleanup);
     return exv;
   }
 
   fir::ExtendedValue
   genExprAddr(const Fortran::lower::SomeExpr &expr,
               Fortran::lower::StatementContext &context,
               mlir::Location *locPtr = nullptr) override final {
     mlir::Location loc = locPtr ? *locPtr : toLocation();
     if (bridge.getLoweringOptions().getLowerToHighLevelFIR()) {
-      hlfir::FortranEntity loweredExpr = Fortran::lower::convertExprToHLFIR(
-          loc, *this, expr, localSymbols, context);
+      hlfir::EntityWithAttributes loweredExpr =
+          Fortran::lower::convertExprToHLFIR(loc, *this, expr, localSymbols,
+                                             context);
       if (fir::FortranVariableOpInterface variable =
               loweredExpr.getIfVariable())
         if (!variable.isBox())
           return translateToExtendedValue(loc, loweredExpr, context);
       TODO(loc, "lower expr that is not a scalar or explicit shape array "
                 "variable to HLFIR address");
     }
     return Fortran::lower::createSomeExtendedAddress(loc, *this, expr,
                                                      localSymbols, context);
   }
 
   fir::ExtendedValue
   genExprValue(const Fortran::lower::SomeExpr &expr,
                Fortran::lower::StatementContext &context,
                mlir::Location *locPtr = nullptr) override final {
     mlir::Location loc = locPtr ? *locPtr : toLocation();
     if (bridge.getLoweringOptions().getLowerToHighLevelFIR()) {
-      hlfir::FortranEntity loweredExpr = Fortran::lower::convertExprToHLFIR(
-          loc, *this, expr, localSymbols, context);
+      hlfir::EntityWithAttributes loweredExpr =
+          Fortran::lower::convertExprToHLFIR(loc, *this, expr, localSymbols,
+                                             context);
       fir::ExtendedValue exv =
           translateToExtendedValue(loc, loweredExpr, context);
       // Load scalar references to integer, logical, real, or complex value
       // to an mlir value, dereference allocatable and pointers, and get rid
       // of fir.box that are no needed or create a copy into contiguous memory.
       return exv.match(
           [&](const fir::UnboxedValue &box) -> fir::ExtendedValue {
             if (mlir::Type elementType = fir::dyn_cast_ptrEleTy(box.getType()))
genExprValue(const Fortran::lower::SomeExpr &expr,
     return Fortran::lower::createSomeExtendedExpression(loc, *this, expr,
                                                         localSymbols, context);
   }
 
   fir::ExtendedValue
   genExprBox(mlir::Location loc, const Fortran::lower::SomeExpr &expr,
              Fortran::lower::StatementContext &stmtCtx) override final {
     if (bridge.getLoweringOptions().getLowerToHighLevelFIR()) {
-      hlfir::FortranEntity loweredExpr = Fortran::lower::convertExprToHLFIR(
-          loc, *this, expr, localSymbols, stmtCtx);
+      hlfir::EntityWithAttributes loweredExpr =
+          Fortran::lower::convertExprToHLFIR(loc, *this, expr, localSymbols,
+                                             stmtCtx);
       if (fir::FortranVariableOpInterface variable =
               loweredExpr.getIfVariable())
         if (variable.isBoxValue() || !variable.isBoxAddress()) {
           auto exv = translateToExtendedValue(loc, loweredExpr, stmtCtx);
           return fir::factory::createBoxValue(getFirOpBuilder(), loc, exv);
         }
       TODO(loc,
            "lower expression value or pointer and allocatable to HLFIR box");

flang/lib/Lower/ConvertExprToHLFIR.cpp

HlfirDesignatorBuilder(mlir::Location loc,
                          Fortran::lower::SymMap &symMap,
                          Fortran::lower::StatementContext &stmtCtx)
       : converter{converter}, symMap{symMap}, stmtCtx{stmtCtx}, loc{loc} {}
 
   // Character designators variant contains substrings
   using CharacterDesignators =
       decltype(Fortran::evaluate::Designator<Fortran::evaluate::Type<
                    Fortran::evaluate::TypeCategory::Character, 1>>::u);
-  hlfir::FortranEntity gen(const CharacterDesignators &designatorVariant) {
+  hlfir::EntityWithAttributes
+  gen(const CharacterDesignators &designatorVariant) {
     return std::visit([&](const auto &x) { return gen(x); }, designatorVariant);
   }
   // Character designators variant contains complex parts
   using RealDesignators =
       decltype(Fortran::evaluate::Designator<Fortran::evaluate::Type<
                    Fortran::evaluate::TypeCategory::Real, 4>>::u);
-  hlfir::FortranEntity gen(const RealDesignators &designatorVariant) {
+  hlfir::EntityWithAttributes gen(const RealDesignators &designatorVariant) {
     return std::visit([&](const auto &x) { return gen(x); }, designatorVariant);
   }
   // All other designators are similar
   using OtherDesignators =
       decltype(Fortran::evaluate::Designator<Fortran::evaluate::Type<
                    Fortran::evaluate::TypeCategory::Integer, 4>>::u);
-  hlfir::FortranEntity gen(const OtherDesignators &designatorVariant) {
+  hlfir::EntityWithAttributes gen(const OtherDesignators &designatorVariant) {
     return std::visit([&](const auto &x) { return gen(x); }, designatorVariant);
   }
 
 private:
-  hlfir::FortranEntity gen(const Fortran::evaluate::SymbolRef &symbolRef) {
+  hlfir::EntityWithAttributes
+  gen(const Fortran::evaluate::SymbolRef &symbolRef) {
     if (llvm::Optional<fir::FortranVariableOpInterface> varDef =
             getSymMap().lookupVariableDefinition(symbolRef))
       return *varDef;
     TODO(getLoc(), "lowering symbol to HLFIR");
   }
-  hlfir::FortranEntity gen(const Fortran::evaluate::Component &component) {
+  hlfir::EntityWithAttributes
+  gen(const Fortran::evaluate::Component &component) {
     TODO(getLoc(), "lowering component to HLFIR");
   }
-  hlfir::FortranEntity gen(const Fortran::evaluate::ArrayRef &arrayRef) {
+  hlfir::EntityWithAttributes gen(const Fortran::evaluate::ArrayRef &arrayRef) {
     TODO(getLoc(), "lowering ArrayRef to HLFIR");
   }
-  hlfir::FortranEntity gen(const Fortran::evaluate::CoarrayRef &coarrayRef) {
+  hlfir::EntityWithAttributes
+  gen(const Fortran::evaluate::CoarrayRef &coarrayRef) {
     TODO(getLoc(), "lowering CoarrayRef to HLFIR");
   }
-  hlfir::FortranEntity gen(const Fortran::evaluate::ComplexPart &complexPart) {
+  hlfir::EntityWithAttributes
+  gen(const Fortran::evaluate::ComplexPart &complexPart) {
     TODO(getLoc(), "lowering complex part to HLFIR");
   }
-  hlfir::FortranEntity gen(const Fortran::evaluate::Substring &substring) {
+  hlfir::EntityWithAttributes
+  gen(const Fortran::evaluate::Substring &substring) {
     TODO(getLoc(), "lowering substrings to HLFIR");
   }
 
   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; }
 
   Fortran::lower::AbstractConverter &converter;
   Fortran::lower::SymMap &symMap;
   Fortran::lower::StatementContext &stmtCtx;
   mlir::Location loc;
 };
 
 /// Lower Expr to HLFIR.
 class HlfirBuilder {
 public:
   HlfirBuilder(mlir::Location loc, Fortran::lower::AbstractConverter &converter,
                Fortran::lower::SymMap &symMap,
                Fortran::lower::StatementContext &stmtCtx)
       : converter{converter}, symMap{symMap}, stmtCtx{stmtCtx}, loc{loc} {}
 
   template <typename T>
-  hlfir::FortranEntity gen(const Fortran::evaluate::Expr<T> &expr) {
+  hlfir::EntityWithAttributes gen(const Fortran::evaluate::Expr<T> &expr) {
     return std::visit([&](const auto &x) { return gen(x); }, expr.u);
   }
 
 private:
-  hlfir::FortranEntity gen(const Fortran::evaluate::BOZLiteralConstant &expr) {
+  hlfir::EntityWithAttributes
+  gen(const Fortran::evaluate::BOZLiteralConstant &expr) {
     fir::emitFatalError(loc, "BOZ literal must be replaced by semantics");
   }
-  hlfir::FortranEntity gen(const Fortran::evaluate::NullPointer &expr) {
+  hlfir::EntityWithAttributes gen(const Fortran::evaluate::NullPointer &expr) {
     TODO(getLoc(), "lowering NullPointer to HLFIR");
   }
-  hlfir::FortranEntity gen(const Fortran::evaluate::ProcedureDesignator &expr) {
+  hlfir::EntityWithAttributes
+  gen(const Fortran::evaluate::ProcedureDesignator &expr) {
     TODO(getLoc(), "lowering ProcDes to HLFIR");
   }
-  hlfir::FortranEntity gen(const Fortran::evaluate::ProcedureRef &expr) {
+  hlfir::EntityWithAttributes gen(const Fortran::evaluate::ProcedureRef &expr) {
     TODO(getLoc(), "lowering ProcRef to HLFIR");
   }
 
   template <typename T>
-  hlfir::FortranEntity gen(const Fortran::evaluate::Designator<T> &designator) {
+  hlfir::EntityWithAttributes
+  gen(const Fortran::evaluate::Designator<T> &designator) {
     return HlfirDesignatorBuilder(getLoc(), getConverter(), getSymMap(),
                                   getStmtCtx())
         .gen(designator.u);
   }
 
   template <typename T>
-  hlfir::FortranEntity gen(const Fortran::evaluate::FunctionRef<T> &expr) {
+  hlfir::EntityWithAttributes
+  gen(const Fortran::evaluate::FunctionRef<T> &expr) {
     TODO(getLoc(), "lowering funcRef to HLFIR");
   }
 
   template <typename T>
-  hlfir::FortranEntity gen(const Fortran::evaluate::Constant<T> &expr) {
+  hlfir::EntityWithAttributes gen(const Fortran::evaluate::Constant<T> &expr) {
     mlir::Location loc = getLoc();
     if constexpr (std::is_same_v<T, Fortran::evaluate::SomeDerived>) {
       TODO(loc, "lowering derived type constant to HLFIR");
     } else {
       fir::FirOpBuilder &builder = getBuilder();
       fir::ExtendedValue exv =
           Fortran::lower::IntrinsicConstantBuilder<T::category, T::kind>::gen(
               builder, loc, expr, /*outlineBigConstantInReadOnlyMemory=*/true);
       if (const auto *scalarBox = exv.getUnboxed())
         if (fir::isa_trivial(scalarBox->getType()))
-          return hlfir::FortranEntity(*scalarBox);
+          return hlfir::EntityWithAttributes(*scalarBox);
       if (auto addressOf = fir::getBase(exv).getDefiningOp<fir::AddrOfOp>()) {
         auto flags = fir::FortranVariableFlagsAttr::get(
             builder.getContext(), fir::FortranVariableFlagsEnum::parameter);
         return hlfir::genDeclare(
             loc, builder, exv,
             addressOf.getSymbol().getRootReference().getValue(), flags);
       }
       fir::emitFatalError(loc, "Constant<T> was lowered to unexpected format");
     }
   }
 
   template <typename T>
-  hlfir::FortranEntity gen(const Fortran::evaluate::ArrayConstructor<T> &expr) {
+  hlfir::EntityWithAttributes
+  gen(const Fortran::evaluate::ArrayConstructor<T> &expr) {
     TODO(getLoc(), "lowering ArrayCtor to HLFIR");
   }
 
   template <Fortran::common::TypeCategory TC1, int KIND,
             Fortran::common::TypeCategory TC2>
-  hlfir::FortranEntity
+  hlfir::EntityWithAttributes
   gen(const Fortran::evaluate::Convert<Fortran::evaluate::Type<TC1, KIND>, TC2>
           &convert) {
     TODO(getLoc(), "lowering convert to HLFIR");
   }
 
   template <typename D, typename R, typename O>
-  hlfir::FortranEntity gen(const Fortran::evaluate::Operation<D, R, O> &op) {
+  hlfir::EntityWithAttributes
+  gen(const Fortran::evaluate::Operation<D, R, O> &op) {
     TODO(getLoc(), "lowering unary op to HLFIR");
   }
 
   template <typename D, typename R, typename LO, typename RO>
-  hlfir::FortranEntity
+  hlfir::EntityWithAttributes
   gen(const Fortran::evaluate::Operation<D, R, LO, RO> &op) {
     TODO(getLoc(), "lowering binary op to HLFIR");
   }
 
-  hlfir::FortranEntity
+  hlfir::EntityWithAttributes
   gen(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &op) {
     return std::visit([&](const auto &x) { return gen(x); }, op.u);
   }
 
-  hlfir::FortranEntity gen(const Fortran::evaluate::TypeParamInquiry &) {
+  hlfir::EntityWithAttributes gen(const Fortran::evaluate::TypeParamInquiry &) {
     TODO(getLoc(), "lowering type parameter inquiry to HLFIR");
   }
 
-  hlfir::FortranEntity gen(const Fortran::evaluate::DescriptorInquiry &desc) {
+  hlfir::EntityWithAttributes
+  gen(const Fortran::evaluate::DescriptorInquiry &desc) {
     TODO(getLoc(), "lowering descriptor inquiry to HLFIR");
   }
 
-  hlfir::FortranEntity gen(const Fortran::evaluate::ImpliedDoIndex &var) {
+  hlfir::EntityWithAttributes
+  gen(const Fortran::evaluate::ImpliedDoIndex &var) {
     TODO(getLoc(), "lowering implied do index to HLFIR");
   }
 
-  hlfir::FortranEntity gen(const Fortran::evaluate::StructureConstructor &var) {
+  hlfir::EntityWithAttributes
+  gen(const Fortran::evaluate::StructureConstructor &var) {
     TODO(getLoc(), "lowering structure constructor to HLFIR");
   }
 
   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; }
 
   Fortran::lower::AbstractConverter &converter;
   Fortran::lower::SymMap &symMap;
   Fortran::lower::StatementContext &stmtCtx;
   mlir::Location loc;
 };
 
 } // namespace
 
-hlfir::FortranEntity Fortran::lower::convertExprToHLFIR(
+hlfir::EntityWithAttributes Fortran::lower::convertExprToHLFIR(
     mlir::Location loc, Fortran::lower::AbstractConverter &converter,
     const Fortran::lower::SomeExpr &expr, Fortran::lower::SymMap &symMap,
     Fortran::lower::StatementContext &stmtCtx) {
   return HlfirBuilder(loc, converter, symMap, stmtCtx).gen(expr);
 }

flang/lib/Optimizer/Builder/HLFIRTools.cpp

getExplicitTypeParams(fir::FortranVariableOpInterface var) {
   llvm::SmallVector<mlir::Value> res;
   mlir::OperandRange range = var.getExplicitTypeParams();
   res.append(range.begin(), range.end());
   return res;
 }
 
 std::pair<fir::ExtendedValue, llvm::Optional<hlfir::CleanupFunction>>
 hlfir::translateToExtendedValue(mlir::Location loc, fir::FirOpBuilder &,
-                                hlfir::FortranEntity entity) {
+                                hlfir::EntityWithAttributes entity) {
   if (auto variable = entity.getIfVariable())
     return {hlfir::translateToExtendedValue(variable), {}};
   if (entity.getType().isa<hlfir::ExprType>())
     TODO(loc, "hlfir.expr to fir::ExtendedValue"); // use hlfir.associate
   return {{static_cast<mlir::Value>(entity)}, {}};
 }
 
 fir::ExtendedValue
if (variable.isCharacter()) {
     return fir::CharBoxValue(variable.getBase(), variable.getExplicitCharLen());
   }
   if (variable.isArray())
     return fir::ArrayBoxValue(variable.getBase(), getExplicitExtents(variable),
                               getExplicitLbounds(variable));
   return variable.getBase();
 }
 
-hlfir::FortranEntity hlfir::genDeclare(mlir::Location loc,
-                                       fir::FirOpBuilder &builder,
-                                       const fir::ExtendedValue &exv,
-                                       llvm::StringRef name,
-                                       fir::FortranVariableFlagsAttr flags) {
+hlfir::EntityWithAttributes
+hlfir::genDeclare(mlir::Location loc, fir::FirOpBuilder &builder,
+                  const fir::ExtendedValue &exv, llvm::StringRef name,
 
   mlir::Value base = fir::getBase(exv);
   assert(fir::isa_passbyref_type(base.getType()) &&
          "entity being declared must be in memory");
   mlir::Value shapeOrShift;
   llvm::SmallVector<mlir::Value> lenParams;
   exv.match(
       [&](const fir::CharBoxValue &box) {

flang/unittests/Optimizer/Builder/HLFIRToolsTest.cpp

 
 TEST_F(HLFIRToolsTest, testScalarRoundTrip) {
   auto &builder = getBuilder();
   mlir::Location loc = getLoc();
   mlir::Type f32Type = mlir::FloatType::getF32(&context);
   mlir::Type scalarf32Type = builder.getRefType(f32Type);
   mlir::Value scalarf32Addr = builder.create<fir::UndefOp>(loc, scalarf32Type);
   fir::ExtendedValue scalarf32{scalarf32Addr};
-  hlfir::FortranEntity scalarf32Entity(createDeclare(scalarf32));
+  hlfir::EntityWithAttributes scalarf32Entity(createDeclare(scalarf32));
   auto [scalarf32Result, cleanup] =
       hlfir::translateToExtendedValue(loc, builder, scalarf32Entity);
   auto *unboxed = scalarf32Result.getUnboxed();
   EXPECT_FALSE(cleanup.has_value());
   ASSERT_NE(unboxed, nullptr);
   EXPECT_TRUE(*unboxed == scalarf32Entity.getBase());
   EXPECT_TRUE(scalarf32Entity.isVariable());
   EXPECT_FALSE(scalarf32Entity.isValue());
 }
 
 TEST_F(HLFIRToolsTest, testArrayRoundTrip) {
   auto &builder = getBuilder();
   mlir::Location loc = getLoc();
   llvm::SmallVector<mlir::Value> extents{
       createConstant(20), createConstant(30)};
   llvm::SmallVector<mlir::Value> lbounds{
       createConstant(-1), createConstant(-2)};
 
   mlir::Type f32Type = mlir::FloatType::getF32(&context);
   mlir::Type seqf32Type = builder.getVarLenSeqTy(f32Type, 2);
   mlir::Type arrayf32Type = builder.getRefType(seqf32Type);
   mlir::Value arrayf32Addr = builder.create<fir::UndefOp>(loc, arrayf32Type);
   fir::ArrayBoxValue arrayf32{arrayf32Addr, extents, lbounds};
-  hlfir::FortranEntity arrayf32Entity(createDeclare(arrayf32));
+  hlfir::EntityWithAttributes arrayf32Entity(createDeclare(arrayf32));
   auto [arrayf32Result, cleanup] =
       hlfir::translateToExtendedValue(loc, builder, arrayf32Entity);
   auto *res = arrayf32Result.getBoxOf<fir::ArrayBoxValue>();
   EXPECT_FALSE(cleanup.has_value());
   ASSERT_NE(res, nullptr);
   // gtest has a terrible time printing mlir::Value in case of failing
   // EXPECT_EQ(mlir::Value, mlir::Value). So use EXPECT_TRUE instead.
   EXPECT_TRUE(fir::getBase(*res) == arrayf32Entity.getBase());
TEST_F(HLFIRToolsTest, testScalarCharRoundTrip) {
   auto &builder = getBuilder();
   mlir::Location loc = getLoc();
   mlir::Value len = createConstant(42);
   mlir::Type charType = fir::CharacterType::getUnknownLen(&context, 1);
   mlir::Type scalarCharType = builder.getRefType(charType);
   mlir::Value scalarCharAddr =
       builder.create<fir::UndefOp>(loc, scalarCharType);
   fir::CharBoxValue scalarChar{scalarCharAddr, len};
-  hlfir::FortranEntity scalarCharEntity(createDeclare(scalarChar));
+  hlfir::EntityWithAttributes scalarCharEntity(createDeclare(scalarChar));
   auto [scalarCharResult, cleanup] =
       hlfir::translateToExtendedValue(loc, builder, scalarCharEntity);
   auto *res = scalarCharResult.getBoxOf<fir::CharBoxValue>();
   EXPECT_FALSE(cleanup.has_value());
   ASSERT_NE(res, nullptr);
   EXPECT_TRUE(fir::getBase(*res) == scalarCharEntity.getBase());
   EXPECT_TRUE(res->getLen() == scalarChar.getLen());
   EXPECT_TRUE(scalarCharEntity.isVariable());
   EXPECT_FALSE(scalarCharEntity.isValue());
 }
 
 TEST_F(HLFIRToolsTest, testArrayCharRoundTrip) {
   auto &builder = getBuilder();
   mlir::Location loc = getLoc();
   llvm::SmallVector<mlir::Value> extents{
       createConstant(20), createConstant(30)};
   llvm::SmallVector<mlir::Value> lbounds{
       createConstant(-1), createConstant(-2)};
   mlir::Value len = createConstant(42);
   mlir::Type charType = fir::CharacterType::getUnknownLen(&context, 1);
   mlir::Type seqCharType = builder.getVarLenSeqTy(charType, 2);
   mlir::Type arrayCharType = builder.getRefType(seqCharType);
   mlir::Value arrayCharAddr = builder.create<fir::UndefOp>(loc, arrayCharType);
   fir::CharArrayBoxValue arrayChar{arrayCharAddr, len, extents, lbounds};
-  hlfir::FortranEntity arrayCharEntity(createDeclare(arrayChar));
+  hlfir::EntityWithAttributes arrayCharEntity(createDeclare(arrayChar));
   auto [arrayCharResult, cleanup] =
       hlfir::translateToExtendedValue(loc, builder, arrayCharEntity);
   auto *res = arrayCharResult.getBoxOf<fir::CharArrayBoxValue>();
   EXPECT_FALSE(cleanup.has_value());
   ASSERT_NE(res, nullptr);
   // gtest has a terrible time printing mlir::Value in case of failing
   // EXPECT_EQ(mlir::Value, mlir::Value). So use EXPECT_TRUE instead.
   EXPECT_TRUE(fir::getBase(*res) == arrayCharEntity.getBase());
TEST_F(HLFIRToolsTest, testArrayCharBoxRoundTrip) {
   mlir::Value len = createConstant(42);
   mlir::Type charType = fir::CharacterType::getUnknownLen(&context, 1);
   mlir::Type seqCharType = builder.getVarLenSeqTy(charType, 2);
   mlir::Type arrayCharBoxType = fir::BoxType::get(seqCharType);
   mlir::Value arrayCharAddr =
       builder.create<fir::UndefOp>(loc, arrayCharBoxType);
   llvm::SmallVector<mlir::Value> explicitTypeParams{len};
   fir::BoxValue arrayChar{arrayCharAddr, lbounds, explicitTypeParams};
-  hlfir::FortranEntity arrayCharEntity(createDeclare(arrayChar));
+  hlfir::EntityWithAttributes arrayCharEntity(createDeclare(arrayChar));
   auto [arrayCharResult, cleanup] =
       hlfir::translateToExtendedValue(loc, builder, arrayCharEntity);
   auto *res = arrayCharResult.getBoxOf<fir::BoxValue>();
   EXPECT_FALSE(cleanup.has_value());
   ASSERT_NE(res, nullptr);
   // gtest has a terrible time printing mlir::Value in case of failing
   // EXPECT_EQ(mlir::Value, mlir::Value). So use EXPECT_TRUE instead.
   EXPECT_TRUE(fir::getBase(*res) == arrayCharEntity.getBase());