[flang][NFC] Centralize fir.class addition in ConvertType

[clementval]

Summary

fir.class type is always needed for polymorphic and unlimited
polymorphic entities. Wrapping the element type with a fir.class
type was done in ConvertType for some case and else where in the
code for other. Centralize this in ConvertType when converting
from expr or symbol.

[jeanPerier]

LGTM

flang/lib/Lower/ConvertType.cpp

291

Will this also fir.class for TYPE(*) ? Until now, fir.box<None> was used for them, right ?
I am not opposed using fir.class for them too, the fallout is just not 100% clear in my mind.

[clementval]

flang/lib/Lower/ConvertType.cpp

291

It's not clear in my mind as well and I think for the time being keeping them as fir.box<none> might be safer. I'll update the boolean value to get rid of assumed type.

[clementval]

Remove Assumed Type

flang/lib/Lower/ConvertType.cpp

struct TypeBuilderImpl {
   template <typename A>
   mlir::Type genExprType(const A &expr) {
     std::optional<Fortran::evaluate::DynamicType> dynamicType = expr.GetType();
     if (!dynamicType)
       return genTypelessExprType(expr);
     Fortran::common::TypeCategory category = dynamicType->category();
 
     mlir::Type baseType;
+    bool isPolymorphic =
+        dynamicType->IsPolymorphic() || dynamicType->IsUnlimitedPolymorphic();
     if (dynamicType->IsUnlimitedPolymorphic()) {
       baseType = mlir::NoneType::get(context);
     } else if (category == Fortran::common::TypeCategory::Derived) {
       baseType = genDerivedType(dynamicType->GetDerivedTypeSpec());
     } else {
       // LOGICAL, INTEGER, REAL, COMPLEX, CHARACTER
       llvm::SmallVector<Fortran::lower::LenParameterTy> params;
       translateLenParameters(params, category, expr);
       baseType = genFIRType(context, category, dynamicType->kind(), params);
     }
     std::optional<Fortran::evaluate::Shape> shapeExpr =
         Fortran::evaluate::GetShape(converter.getFoldingContext(), expr);
     fir::SequenceType::Shape shape;
     if (shapeExpr) {
       translateShape(shape, std::move(*shapeExpr));
     } else {
       // Shape static analysis cannot return something useful for the shape.
       // Use unknown extents.
       int rank = expr.Rank();
       if (rank < 0)
         TODO(converter.getCurrentLocation(), "assumed rank expression types");
       for (int dim = 0; dim < rank; ++dim)
         shape.emplace_back(fir::SequenceType::getUnknownExtent());
     }
-    if (!shape.empty())
+
+    if (!shape.empty()) {
+      if (isPolymorphic)
+        return fir::ClassType::get(fir::SequenceType::get(shape, baseType));
       return fir::SequenceType::get(shape, baseType);
+    }
+    if (isPolymorphic)
+      return fir::ClassType::get(baseType);
     return baseType;
   }
 
   template <typename A>
   void translateShape(A &shape, Fortran::evaluate::Shape &&shapeExpr) {
     for (Fortran::evaluate::MaybeExtentExpr extentExpr : shapeExpr) {
       fir::SequenceType::Extent extent = fir::SequenceType::getUnknownExtent();
       if (std::optional<std::int64_t> constantExtent =
if (const Fortran::semantics::DeclTypeSpec *type = ultimate.GetType()) {
                      type->AsDerived()) {
         ty = genDerivedType(*tySpec);
       } else {
         fir::emitFatalError(loc, "symbol's type must have a type spec");
       }
     } else {
       fir::emitFatalError(loc, "symbol must have a type");
     }
+    bool isPolymorphic = Fortran::semantics::IsPolymorphic(symbol) ||
+                         Fortran::semantics::IsUnlimitedPolymorphic(symbol);
     if (ultimate.IsObjectArray()) {
       auto shapeExpr = Fortran::evaluate::GetShapeHelper{
           converter.getFoldingContext()}(ultimate);
       if (!shapeExpr)
         TODO(loc, "assumed rank symbol type");
       fir::SequenceType::Shape shape;
       translateShape(shape, std::move(*shapeExpr));
       ty = fir::SequenceType::get(shape, ty);
     }
     if (Fortran::semantics::IsPointer(symbol))
-      return fir::wrapInClassOrBoxType(
-          fir::PointerType::get(ty), Fortran::semantics::IsPolymorphic(symbol));
+      return fir::wrapInClassOrBoxType(fir::PointerType::get(ty),
+                                       isPolymorphic);
     if (Fortran::semantics::IsAllocatable(symbol))
-      return fir::wrapInClassOrBoxType(
-          fir::HeapType::get(ty), Fortran::semantics::IsPolymorphic(symbol));
+      return fir::wrapInClassOrBoxType(fir::HeapType::get(ty), isPolymorphic);
     // isPtr and isAlloc are variable that were promoted to be on the
     // heap or to be pointers, but they do not have Fortran allocatable
     // or pointer semantics, so do not use box for them.
     if (isPtr)
       return fir::PointerType::get(ty);
     if (isAlloc)
       return fir::HeapType::get(ty);
+    if (isPolymorphic)
+      return fir::ClassType::get(ty);
     return ty;
   }
 
   /// Does \p component has non deferred lower bounds that are not compile time
   /// constant 1.
   static bool componentHasNonDefaultLowerBounds(
       const Fortran::semantics::Symbol &component) {
     if (const auto *objDetails =

flang/lib/Lower/HostAssociations.cpp

 }
 
 /// Class defining how polymorphic entities are captured in internal procedures.
 /// Polymorphic entities are always boxed as a fir.class box.
 class CapturedPolymorphic : public CapturedSymbols<CapturedPolymorphic> {
 public:
   static mlir::Type getType(Fortran::lower::AbstractConverter &converter,
                             const Fortran::semantics::Symbol &sym) {
-    return fir::ClassType::get(converter.genType(sym));
+    return converter.genType(sym);
   }
   static void instantiateHostTuple(const InstantiateHostTuple &args,
                                    Fortran::lower::AbstractConverter &converter,
                                    const Fortran::semantics::Symbol &) {
     fir::FirOpBuilder &builder = converter.getFirOpBuilder();
     mlir::Type typeInTuple = fir::dyn_cast_ptrEleTy(args.addrInTuple.getType());
     assert(typeInTuple && "addrInTuple must be an address");
     mlir::Value castBox = builder.createConvert(args.loc, typeInTuple,